Transaction Hash:
Block:
21237625 at Nov-21-2024 05:33:59 PM +UTC
Transaction Fee:
0.0006858017712399 ETH
$1.52
Gas Used:
47,180 Gas / 14.535857805 Gwei
Emitted Events:
| 423 |
LUSDToken.Transfer( from=[Sender] 0xee518f8b71d1163ddbc4ef7f58299d62d8a6b976, to=0xe4f2803B4AaA9dAd386baA8f9e92E98A75C3aD9c, value=23830762693354111175090 )
|
Account State Difference:
| Address | Before | After | State Difference | ||
|---|---|---|---|---|---|
| 0x5f98805A...8C6568bA0 | |||||
|
0x95222290...5CC4BAfe5
Miner
| (beaverbuild) | 11.002076064745782602 Eth | 11.002136348622778602 Eth | 0.000060283876996 | |
| 0xeE518F8B...2D8A6b976 |
0.013231881819541943 Eth
Nonce: 38
|
0.012546080048302043 Eth
Nonce: 39
| 0.0006858017712399 |
Execution Trace
LUSDToken.transfer( recipient=0xe4f2803B4AaA9dAd386baA8f9e92E98A75C3aD9c, amount=23830762693354111175090 ) => ( True )
// SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
import "./Interfaces/ILUSDToken.sol";
import "./Dependencies/SafeMath.sol";
import "./Dependencies/CheckContract.sol";
import "./Dependencies/console.sol";
/*
*
* Based upon OpenZeppelin's ERC20 contract:
* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol
*
* and their EIP2612 (ERC20Permit / ERC712) functionality:
* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/53516bc555a454862470e7860a9b5254db4d00f5/contracts/token/ERC20/ERC20Permit.sol
*
*
* --- Functionality added specific to the LUSDToken ---
*
* 1) Transfer protection: blacklist of addresses that are invalid recipients (i.e. core Liquity contracts) in external
* transfer() and transferFrom() calls. The purpose is to protect users from losing tokens by mistakenly sending LUSD directly to a Liquity
* core contract, when they should rather call the right function.
*
* 2) sendToPool() and returnFromPool(): functions callable only Liquity core contracts, which move LUSD tokens between Liquity <-> user.
*/
contract LUSDToken is CheckContract, ILUSDToken {
using SafeMath for uint256;
uint256 private _totalSupply;
string constant internal _NAME = "LUSD Stablecoin";
string constant internal _SYMBOL = "LUSD";
string constant internal _VERSION = "1";
uint8 constant internal _DECIMALS = 18;
// --- Data for EIP2612 ---
// keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 private constant _PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
// keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 private constant _TYPE_HASH = 0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f;
// Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
// invalidate the cached domain separator if the chain id changes.
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
mapping (address => uint256) private _nonces;
// User data for LUSD token
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
// --- Addresses ---
address public immutable troveManagerAddress;
address public immutable stabilityPoolAddress;
address public immutable borrowerOperationsAddress;
// --- Events ---
event TroveManagerAddressChanged(address _troveManagerAddress);
event StabilityPoolAddressChanged(address _newStabilityPoolAddress);
event BorrowerOperationsAddressChanged(address _newBorrowerOperationsAddress);
constructor
(
address _troveManagerAddress,
address _stabilityPoolAddress,
address _borrowerOperationsAddress
)
public
{
checkContract(_troveManagerAddress);
checkContract(_stabilityPoolAddress);
checkContract(_borrowerOperationsAddress);
troveManagerAddress = _troveManagerAddress;
emit TroveManagerAddressChanged(_troveManagerAddress);
stabilityPoolAddress = _stabilityPoolAddress;
emit StabilityPoolAddressChanged(_stabilityPoolAddress);
borrowerOperationsAddress = _borrowerOperationsAddress;
emit BorrowerOperationsAddressChanged(_borrowerOperationsAddress);
bytes32 hashedName = keccak256(bytes(_NAME));
bytes32 hashedVersion = keccak256(bytes(_VERSION));
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = _chainID();
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(_TYPE_HASH, hashedName, hashedVersion);
}
// --- Functions for intra-Liquity calls ---
function mint(address _account, uint256 _amount) external override {
_requireCallerIsBorrowerOperations();
_mint(_account, _amount);
}
function burn(address _account, uint256 _amount) external override {
_requireCallerIsBOorTroveMorSP();
_burn(_account, _amount);
}
function sendToPool(address _sender, address _poolAddress, uint256 _amount) external override {
_requireCallerIsStabilityPool();
_transfer(_sender, _poolAddress, _amount);
}
function returnFromPool(address _poolAddress, address _receiver, uint256 _amount) external override {
_requireCallerIsTroveMorSP();
_transfer(_poolAddress, _receiver, _amount);
}
// --- External functions ---
function totalSupply() external view override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) external view override returns (uint256) {
return _balances[account];
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
_requireValidRecipient(recipient);
_transfer(msg.sender, recipient, amount);
return true;
}
function allowance(address owner, address spender) external view override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external override returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
_requireValidRecipient(recipient);
_transfer(sender, recipient, amount);
_approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
}
function increaseAllowance(address spender, uint256 addedValue) external override returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) external override returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
return true;
}
// --- EIP 2612 Functionality ---
function domainSeparator() public view override returns (bytes32) {
if (_chainID() == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function permit
(
address owner,
address spender,
uint amount,
uint deadline,
uint8 v,
bytes32 r,
bytes32 s
)
external
override
{
require(deadline >= now, 'LUSD: expired deadline');
bytes32 digest = keccak256(abi.encodePacked('\\x19\\x01',
domainSeparator(), keccak256(abi.encode(
_PERMIT_TYPEHASH, owner, spender, amount,
_nonces[owner]++, deadline))));
address recoveredAddress = ecrecover(digest, v, r, s);
require(recoveredAddress == owner, 'LUSD: invalid signature');
_approve(owner, spender, amount);
}
function nonces(address owner) external view override returns (uint256) { // FOR EIP 2612
return _nonces[owner];
}
// --- Internal operations ---
function _chainID() private pure returns (uint256 chainID) {
assembly {
chainID := chainid()
}
}
function _buildDomainSeparator(bytes32 typeHash, bytes32 name, bytes32 version) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, name, version, _chainID(), address(this)));
}
// --- Internal operations ---
// Warning: sanity checks (for sender and recipient) should have been done before calling these internal functions
function _transfer(address sender, address recipient, uint256 amount) internal {
assert(sender != address(0));
assert(recipient != address(0));
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(sender, recipient, amount);
}
function _mint(address account, uint256 amount) internal {
assert(account != address(0));
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal {
assert(account != address(0));
_balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
_totalSupply = _totalSupply.sub(amount);
emit Transfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal {
assert(owner != address(0));
assert(spender != address(0));
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
// --- 'require' functions ---
function _requireValidRecipient(address _recipient) internal view {
require(
_recipient != address(0) &&
_recipient != address(this),
"LUSD: Cannot transfer tokens directly to the LUSD token contract or the zero address"
);
require(
_recipient != stabilityPoolAddress &&
_recipient != troveManagerAddress &&
_recipient != borrowerOperationsAddress,
"LUSD: Cannot transfer tokens directly to the StabilityPool, TroveManager or BorrowerOps"
);
}
function _requireCallerIsBorrowerOperations() internal view {
require(msg.sender == borrowerOperationsAddress, "LUSDToken: Caller is not BorrowerOperations");
}
function _requireCallerIsBOorTroveMorSP() internal view {
require(
msg.sender == borrowerOperationsAddress ||
msg.sender == troveManagerAddress ||
msg.sender == stabilityPoolAddress,
"LUSD: Caller is neither BorrowerOperations nor TroveManager nor StabilityPool"
);
}
function _requireCallerIsStabilityPool() internal view {
require(msg.sender == stabilityPoolAddress, "LUSD: Caller is not the StabilityPool");
}
function _requireCallerIsTroveMorSP() internal view {
require(
msg.sender == troveManagerAddress || msg.sender == stabilityPoolAddress,
"LUSD: Caller is neither TroveManager nor StabilityPool");
}
// --- Optional functions ---
function name() external view override returns (string memory) {
return _NAME;
}
function symbol() external view override returns (string memory) {
return _SYMBOL;
}
function decimals() external view override returns (uint8) {
return _DECIMALS;
}
function version() external view override returns (string memory) {
return _VERSION;
}
function permitTypeHash() external view override returns (bytes32) {
return _PERMIT_TYPEHASH;
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
import "../Dependencies/IERC20.sol";
import "../Dependencies/IERC2612.sol";
interface ILUSDToken is IERC20, IERC2612 {
// --- Events ---
event TroveManagerAddressChanged(address _troveManagerAddress);
event StabilityPoolAddressChanged(address _newStabilityPoolAddress);
event BorrowerOperationsAddressChanged(address _newBorrowerOperationsAddress);
event LUSDTokenBalanceUpdated(address _user, uint _amount);
// --- Functions ---
function mint(address _account, uint256 _amount) external;
function burn(address _account, uint256 _amount) external;
function sendToPool(address _sender, address poolAddress, uint256 _amount) external;
function returnFromPool(address poolAddress, address user, uint256 _amount ) external;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
/**
* Based on OpenZeppelin's SafeMath:
* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/SafeMath.sol
*
* @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: addition overflow");
return c;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
* - Subtraction cannot overflow.
*
* _Available since v2.4.0._
*/
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
/**
* @dev Returns the integer division of two unsigned integers. Reverts with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
// Solidity only automatically asserts when dividing by 0
require(b > 0, errorMessage);
uint256 c = a / b;
// assert(a == b * c + a % b); // There is no case in which this doesn't hold
return c;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* Reverts with custom message when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
* - The divisor cannot be zero.
*
* _Available since v2.4.0._
*/
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
contract CheckContract {
/**
* Check that the account is an already deployed non-destroyed contract.
* See: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol#L12
*/
function checkContract(address _account) internal view {
require(_account != address(0), "Account cannot be zero address");
uint256 size;
// solhint-disable-next-line no-inline-assembly
assembly { size := extcodesize(_account) }
require(size > 0, "Account code size cannot be zero");
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
// Buidler's helper contract for console logging
library console {
\taddress constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);
\tfunction log() internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log()"));
\t\tignored;
\t}\tfunction logInt(int p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(int)", p0));
\t\tignored;
\t}
\tfunction logUint(uint p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint)", p0));
\t\tignored;
\t}
\tfunction logString(string memory p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string)", p0));
\t\tignored;
\t}
\tfunction logBool(bool p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool)", p0));
\t\tignored;
\t}
\tfunction logAddress(address p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address)", p0));
\t\tignored;
\t}
\tfunction logBytes(bytes memory p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes)", p0));
\t\tignored;
\t}
\tfunction logByte(byte p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(byte)", p0));
\t\tignored;
\t}
\tfunction logBytes1(bytes1 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes1)", p0));
\t\tignored;
\t}
\tfunction logBytes2(bytes2 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes2)", p0));
\t\tignored;
\t}
\tfunction logBytes3(bytes3 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes3)", p0));
\t\tignored;
\t}
\tfunction logBytes4(bytes4 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes4)", p0));
\t\tignored;
\t}
\tfunction logBytes5(bytes5 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes5)", p0));
\t\tignored;
\t}
\tfunction logBytes6(bytes6 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes6)", p0));
\t\tignored;
\t}
\tfunction logBytes7(bytes7 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes7)", p0));
\t\tignored;
\t}
\tfunction logBytes8(bytes8 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes8)", p0));
\t\tignored;
\t}
\tfunction logBytes9(bytes9 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes9)", p0));
\t\tignored;
\t}
\tfunction logBytes10(bytes10 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes10)", p0));
\t\tignored;
\t}
\tfunction logBytes11(bytes11 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes11)", p0));
\t\tignored;
\t}
\tfunction logBytes12(bytes12 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes12)", p0));
\t\tignored;
\t}
\tfunction logBytes13(bytes13 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes13)", p0));
\t\tignored;
\t}
\tfunction logBytes14(bytes14 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes14)", p0));
\t\tignored;
\t}
\tfunction logBytes15(bytes15 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes15)", p0));
\t\tignored;
\t}
\tfunction logBytes16(bytes16 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes16)", p0));
\t\tignored;
\t}
\tfunction logBytes17(bytes17 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes17)", p0));
\t\tignored;
\t}
\tfunction logBytes18(bytes18 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes18)", p0));
\t\tignored;
\t}
\tfunction logBytes19(bytes19 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes19)", p0));
\t\tignored;
\t}
\tfunction logBytes20(bytes20 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes20)", p0));
\t\tignored;
\t}
\tfunction logBytes21(bytes21 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes21)", p0));
\t\tignored;
\t}
\tfunction logBytes22(bytes22 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes22)", p0));
\t\tignored;
\t}
\tfunction logBytes23(bytes23 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes23)", p0));
\t\tignored;
\t}
\tfunction logBytes24(bytes24 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes24)", p0));
\t\tignored;
\t}
\tfunction logBytes25(bytes25 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes25)", p0));
\t\tignored;
\t}
\tfunction logBytes26(bytes26 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes26)", p0));
\t\tignored;
\t}
\tfunction logBytes27(bytes27 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes27)", p0));
\t\tignored;
\t}
\tfunction logBytes28(bytes28 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes28)", p0));
\t\tignored;
\t}
\tfunction logBytes29(bytes29 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes29)", p0));
\t\tignored;
\t}
\tfunction logBytes30(bytes30 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes30)", p0));
\t\tignored;
\t}
\tfunction logBytes31(bytes31 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes31)", p0));
\t\tignored;
\t}
\tfunction logBytes32(bytes32 p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bytes32)", p0));
\t\tignored;
\t}
\tfunction log(uint p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint)", p0));
\t\tignored;
\t}
\tfunction log(string memory p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string)", p0));
\t\tignored;
\t}
\tfunction log(bool p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool)", p0));
\t\tignored;
\t}
\tfunction log(address p0) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address)", p0));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint)", p0, p1));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string)", p0, p1));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool)", p0, p1));
\t\tignored;
\t}
\tfunction log(uint p0, address p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address)", p0, p1));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint)", p0, p1));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string)", p0, p1));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool)", p0, p1));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address)", p0, p1));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint)", p0, p1));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string)", p0, p1));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool)", p0, p1));
\t\tignored;
\t}
\tfunction log(bool p0, address p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address)", p0, p1));
\t\tignored;
\t}
\tfunction log(address p0, uint p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint)", p0, p1));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string)", p0, p1));
\t\tignored;
\t}
\tfunction log(address p0, bool p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool)", p0, p1));
\t\tignored;
\t}
\tfunction log(address p0, address p1) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address)", p0, p1));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, address p1, uint p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, address p1, string memory p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, address p1, bool p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(address p0, address p1, address p2) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, uint p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, string memory p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, bool p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(uint p0, address p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, uint p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, string memory p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, bool p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(string memory p0, address p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, uint p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, string memory p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, bool p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(bool p0, address p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, uint p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, string memory p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, bool p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, uint p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, uint p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, uint p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, uint p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, string memory p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, string memory p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, string memory p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, string memory p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, bool p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, bool p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, bool p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, bool p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, address p2, uint p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, address p2, string memory p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, address p2, bool p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
\t\tignored;
\t}
\tfunction log(address p0, address p1, address p2, address p3) internal view {
\t\t(bool ignored, ) = CONSOLE_ADDRESS.staticcall(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
\t\tignored;
\t}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
/**
* Based on the OpenZeppelin IER20 interface:
* https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/IERC20.sol
*
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
/**
* @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);
}// SPDX-License-Identifier: MIT
pragma solidity 0.6.11;
/**
* @dev Interface of the ERC2612 standard as defined in the EIP.
*
* Adds the {permit} method, which can be used to change one's
* {IERC20-allowance} without having to send a transaction, by signing a
* message. This allows users to spend tokens without having to hold Ether.
*
* See https://eips.ethereum.org/EIPS/eip-2612.
*
* Code adapted from https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2237/
*/
interface IERC2612 {
/**
* @dev Sets `amount` as the allowance of `spender` over `owner`'s tokens,
* given `owner`'s signed approval.
*
* IMPORTANT: The same issues {IERC20-approve} has related to transaction
* ordering also apply here.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
* - `deadline` must be a timestamp in the future.
* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
* over the EIP712-formatted function arguments.
* - the signature must use ``owner``'s current nonce (see {nonces}).
*
* For more information on the signature format, see the
* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
* section].
*/
function permit(address owner, address spender, uint256 amount,
uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;
/**
* @dev Returns the current ERC2612 nonce for `owner`. This value must be
* included whenever a signature is generated for {permit}.
*
* Every successful call to {permit} increases `owner`'s nonce by one. This
* prevents a signature from being used multiple times.
*
* `owner` can limit the time a Permit is valid for by setting `deadline` to
* a value in the near future. The deadline argument can be set to uint(-1) to
* create Permits that effectively never expire.
*/
function nonces(address owner) external view returns (uint256);
function version() external view returns (string memory);
function permitTypeHash() external view returns (bytes32);
function domainSeparator() external view returns (bytes32);
}