ETH Price: $2,979.22 (-1.50%)

Transaction Decoder

Block:
22019339 at Mar-10-2025 10:05:35 PM +UTC
Transaction Fee:
0.000411459457289628 ETH $1.23
Gas Used:
183,854 Gas / 2.237968482 Gwei

Emitted Events:

56 Token.Approval( owner=[Sender] 0xed19d805d8f0372c6ac8abe9954ebf1362ae14fd, spender=[Receiver] RedSnwapper, value=0 )
57 Token.Transfer( from=[Sender] 0xed19d805d8f0372c6ac8abe9954ebf1362ae14fd, to=0x85CD07Ea01423b1E937929B44E4Ad8c40BbB5E71, value=128389266068606450000 )
58 Token.Transfer( from=0x85CD07Ea01423b1E937929B44E4Ad8c40BbB5E71, to=PancakePair, value=128389266068606449999 )
59 TetherToken.Transfer( from=PancakePair, to=0x85CD07Ea01423b1E937929B44E4Ad8c40BbB5E71, value=6088236 )
60 PancakePair.Sync( reserve0=22700072247493950714739, reserve1=1073034798 )
61 PancakePair.Swap( sender=0x85CD07Ea01423b1E937929B44E4Ad8c40BbB5E71, amount0In=128389266068606449999, amount1In=0, amount0Out=0, amount1Out=6088236, to=0x85CD07Ea01423b1E937929B44E4Ad8c40BbB5E71 )
62 0x85cd07ea01423b1e937929b44e4ad8c40bbb5e71.0x1bf1122521093cffed0b7f29833cd231d885bae58dceb074e411a1fbd94824bd( 0x1bf1122521093cffed0b7f29833cd231d885bae58dceb074e411a1fbd94824bd, 0x000000000000000000000000ad27827c312cd5e71311d68e180a9872d42de23d, 0x0000000000000000000000007da2641000cbb407c329310c461b2cb9c70c3046, 0x0000000000000000000000000000000000000000000000000000000000000000, 00000000000000000000000085cd07ea01423b1e937929b44e4ad8c40bbb5e71, 000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7, 000000000000000000000000000000000000000000000006f5c24d410066794f, 00000000000000000000000000000000000000000000000000000000005cb69b, 00000000000000000000000000000000000000000000000000000000005ce62c, 0000000000000000000000000000000000000000000000000000000000000000 )
63 TetherToken.Transfer( from=0x85CD07Ea01423b1E937929B44E4Ad8c40BbB5E71, to=TokenChomper, value=15190 )
64 TetherToken.Transfer( from=0x85CD07Ea01423b1E937929B44E4Ad8c40BbB5E71, to=[Sender] 0xed19d805d8f0372c6ac8abe9954ebf1362ae14fd, value=6073046 )

Account State Difference:

  Address   Before After State Difference Code
(Titan Builder)
9.747158237461535384 Eth9.747250164461535384 Eth0.000091927
0x7dA26410...9c70C3046
0x99E5068E...61F8684Bd
0xdAC17F95...13D831ec7
0xED19D805...362Ae14fd
0.008909058151821849 Eth
Nonce: 99
0.008497598694532221 Eth
Nonce: 100
0.000411459457289628

Execution Trace

RedSnwapper.snwap( tokenIn=0x7dA2641000Cbb407C329310C461b2cB9c70C3046, amountIn=128389266068606450000, recipient=0xED19D805d8f0372c6Ac8Abe9954EBF1362Ae14fd, tokenOut=0xdAC17F958D2ee523a2206206994597C13D831ec7, amountOutMin=6060869, executor=0x85CD07Ea01423b1E937929B44E4Ad8c40BbB5E71, executorData=0xEE623204000000000000000000000000CA226BD9C754F1283123D32B2A7CF62A722F8ADA0000000000000000000000000000000000000000000000000000000000003B560000000000000000000000007DA2641000CBB407C329310C461B2CB9C70C3046000000000000000000000000000000000000000000000006F5C24D4100667950000000000000000000000000DAC17F958D2EE523A2206206994597C13D831EC700000000000000000000000000000000000000000000000000000000005CE62C00000000000000000000000000000000000000000000000000000000005CB69B000000000000000000000000ED19D805D8F0372C6AC8ABE9954EBF1362AE14FD000000000000000000000000000000000000000000000000000000000000014000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000045017DA2641000CBB407C329310C461B2CB9C70C304601FFFF0099E5068E762677839E77DA46E684EDD61F8684BD0185CD07EA01423B1E937929B44E4AD8C40BBB5E710009C4000000000000000000000000000000000000000000000000000000 ) => ( amountOut=6073046 )
  • TetherToken.balanceOf( who=0xED19D805d8f0372c6Ac8Abe9954EBF1362Ae14fd ) => ( 65164940 )
  • Token.transferFrom( from=0xED19D805d8f0372c6Ac8Abe9954EBF1362Ae14fd, to=0x85CD07Ea01423b1E937929B44E4Ad8c40BbB5E71, amount=128389266068606450000 ) => ( True )
  • 0xad27827c312cd5e71311d68e180a9872d42de23d.1cff79cd( )
    • 0x85cd07ea01423b1e937929b44e4ad8c40bbb5e71.ee623204( )
      • Token.balanceOf( account=0xAD27827C312Cd5E71311d68e180a9872d42dE23D ) => ( 0 )
      • TetherToken.balanceOf( who=0x85CD07Ea01423b1E937929B44E4Ad8c40BbB5E71 ) => ( 1 )
      • Token.balanceOf( account=0x85CD07Ea01423b1E937929B44E4Ad8c40BbB5E71 ) => ( 128389266068606450000 )
      • Token.transfer( to=0x99E5068E762677839e77Da46e684EdD61F8684Bd, amount=128389266068606449999 ) => ( True )
      • PancakePair.STATICCALL( )
      • Token.balanceOf( account=0x99E5068E762677839e77Da46e684EdD61F8684Bd ) => ( 22700072247493950714739 )
      • PancakePair.swap( amount0Out=0, amount1Out=6088236, to=0x85CD07Ea01423b1E937929B44E4Ad8c40BbB5E71, data=0x )
        • TetherToken.transfer( _to=0x85CD07Ea01423b1E937929B44E4Ad8c40BbB5E71, _value=6088236 )
        • Token.balanceOf( account=0x99E5068E762677839e77Da46e684EdD61F8684Bd ) => ( 22700072247493950714739 )
        • TetherToken.balanceOf( who=0x99E5068E762677839e77Da46e684EdD61F8684Bd ) => ( 1073034798 )
        • Token.balanceOf( account=0xAD27827C312Cd5E71311d68e180a9872d42dE23D ) => ( 0 )
        • TetherToken.balanceOf( who=0x85CD07Ea01423b1E937929B44E4Ad8c40BbB5E71 ) => ( 6088237 )
        • TetherToken.transfer( _to=0xca226bd9c754F1283123d32B2a7cF62a722f8ADa, _value=15190 )
        • TetherToken.transfer( _to=0xED19D805d8f0372c6Ac8Abe9954EBF1362Ae14fd, _value=6073046 )
        • TetherToken.balanceOf( who=0xED19D805d8f0372c6Ac8Abe9954EBF1362Ae14fd ) => ( 71237986 )
          File 1 of 5: RedSnwapper
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
          pragma solidity ^0.8.0;
          /**
           * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
           * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
           *
           * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
           * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
           * need to send a transaction, and thus is not required to hold Ether at all.
           */
          interface IERC20Permit {
              /**
               * @dev Sets `value` 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:
               *
               * - `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 value,
                  uint256 deadline,
                  uint8 v,
                  bytes32 r,
                  bytes32 s
              ) external;
              /**
               * @dev Returns the current 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.
               */
              function nonces(address owner) external view returns (uint256);
              /**
               * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
               */
              // solhint-disable-next-line func-name-mixedcase
              function DOMAIN_SEPARATOR() external view returns (bytes32);
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
          pragma solidity ^0.8.0;
          /**
           * @dev Interface of the ERC20 standard as defined in the EIP.
           */
          interface IERC20 {
              /**
               * @dev Emitted when `value` tokens are moved from one account (`from`) to
               * another (`to`).
               *
               * Note that `value` may be zero.
               */
              event Transfer(address indexed from, address indexed to, uint256 value);
              /**
               * @dev Emitted when the allowance of a `spender` for an `owner` is set by
               * a call to {approve}. `value` is the new allowance.
               */
              event Approval(address indexed owner, address indexed spender, uint256 value);
              /**
               * @dev Returns the 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 `to`.
               *
               * Returns a boolean value indicating whether the operation succeeded.
               *
               * Emits a {Transfer} event.
               */
              function transfer(address to, uint256 amount) external returns (bool);
              /**
               * @dev Returns the remaining number of tokens that `spender` will be
               * allowed to spend on behalf of `owner` through {transferFrom}. This is
               * zero by default.
               *
               * This value changes when {approve} or {transferFrom} are called.
               */
              function allowance(address owner, address spender) external view returns (uint256);
              /**
               * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
               *
               * Returns a boolean value indicating whether the operation succeeded.
               *
               * IMPORTANT: Beware that changing an allowance with this method brings the risk
               * that someone may use both the old and the new allowance by unfortunate
               * transaction ordering. One possible solution to mitigate this race
               * condition is to first reduce the spender's allowance to 0 and set the
               * desired value afterwards:
               * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
               *
               * Emits an {Approval} event.
               */
              function approve(address spender, uint256 amount) external returns (bool);
              /**
               * @dev Moves `amount` tokens from `from` to `to` 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 from,
                  address to,
                  uint256 amount
              ) external returns (bool);
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)
          pragma solidity ^0.8.0;
          import "../IERC20.sol";
          import "../extensions/draft-IERC20Permit.sol";
          import "../../../utils/Address.sol";
          /**
           * @title SafeERC20
           * @dev Wrappers around ERC20 operations that throw on failure (when the token
           * contract returns false). Tokens that return no value (and instead revert or
           * throw on failure) are also supported, non-reverting calls are assumed to be
           * successful.
           * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
           * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
           */
          library SafeERC20 {
              using Address for address;
              function safeTransfer(
                  IERC20 token,
                  address to,
                  uint256 value
              ) internal {
                  _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
              }
              function safeTransferFrom(
                  IERC20 token,
                  address from,
                  address to,
                  uint256 value
              ) internal {
                  _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
              }
              /**
               * @dev Deprecated. This function has issues similar to the ones found in
               * {IERC20-approve}, and its usage is discouraged.
               *
               * Whenever possible, use {safeIncreaseAllowance} and
               * {safeDecreaseAllowance} instead.
               */
              function safeApprove(
                  IERC20 token,
                  address spender,
                  uint256 value
              ) internal {
                  // safeApprove should only be called when setting an initial allowance,
                  // or when resetting it to zero. To increase and decrease it, use
                  // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
                  require(
                      (value == 0) || (token.allowance(address(this), spender) == 0),
                      "SafeERC20: approve from non-zero to non-zero allowance"
                  );
                  _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
              }
              function safeIncreaseAllowance(
                  IERC20 token,
                  address spender,
                  uint256 value
              ) internal {
                  uint256 newAllowance = token.allowance(address(this), spender) + value;
                  _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
              }
              function safeDecreaseAllowance(
                  IERC20 token,
                  address spender,
                  uint256 value
              ) internal {
                  unchecked {
                      uint256 oldAllowance = token.allowance(address(this), spender);
                      require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
                      uint256 newAllowance = oldAllowance - value;
                      _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
                  }
              }
              function safePermit(
                  IERC20Permit token,
                  address owner,
                  address spender,
                  uint256 value,
                  uint256 deadline,
                  uint8 v,
                  bytes32 r,
                  bytes32 s
              ) internal {
                  uint256 nonceBefore = token.nonces(owner);
                  token.permit(owner, spender, value, deadline, v, r, s);
                  uint256 nonceAfter = token.nonces(owner);
                  require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
              }
              /**
               * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
               * on the return value: the return value is optional (but if data is returned, it must not be false).
               * @param token The token targeted by the call.
               * @param data The call data (encoded using abi.encode or one of its variants).
               */
              function _callOptionalReturn(IERC20 token, bytes memory data) private {
                  // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
                  // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
                  // the target address contains contract code and also asserts for success in the low-level call.
                  bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
                  if (returndata.length > 0) {
                      // Return data is optional
                      require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
                  }
              }
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
          pragma solidity ^0.8.1;
          /**
           * @dev Collection of functions related to the address type
           */
          library Address {
              /**
               * @dev Returns true if `account` is a contract.
               *
               * [IMPORTANT]
               * ====
               * It is unsafe to assume that an address for which this function returns
               * false is an externally-owned account (EOA) and not a contract.
               *
               * Among others, `isContract` will return false for the following
               * types of addresses:
               *
               *  - an externally-owned account
               *  - a contract in construction
               *  - an address where a contract will be created
               *  - an address where a contract lived, but was destroyed
               * ====
               *
               * [IMPORTANT]
               * ====
               * You shouldn't rely on `isContract` to protect against flash loan attacks!
               *
               * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
               * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
               * constructor.
               * ====
               */
              function isContract(address account) internal view returns (bool) {
                  // This method relies on extcodesize/address.code.length, which returns 0
                  // for contracts in construction, since the code is only stored at the end
                  // of the constructor execution.
                  return account.code.length > 0;
              }
              /**
               * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
               * `recipient`, forwarding all available gas and reverting on errors.
               *
               * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
               * of certain opcodes, possibly making contracts go over the 2300 gas limit
               * imposed by `transfer`, making them unable to receive funds via
               * `transfer`. {sendValue} removes this limitation.
               *
               * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
               *
               * IMPORTANT: because control is transferred to `recipient`, care must be
               * taken to not create reentrancy vulnerabilities. Consider using
               * {ReentrancyGuard} or the
               * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
               */
              function sendValue(address payable recipient, uint256 amount) internal {
                  require(address(this).balance >= amount, "Address: insufficient balance");
                  (bool success, ) = recipient.call{value: amount}("");
                  require(success, "Address: unable to send value, recipient may have reverted");
              }
              /**
               * @dev Performs a Solidity function call using a low level `call`. A
               * plain `call` is an unsafe replacement for a function call: use this
               * function instead.
               *
               * If `target` reverts with a revert reason, it is bubbled up by this
               * function (like regular Solidity function calls).
               *
               * Returns the raw returned data. To convert to the expected return value,
               * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
               *
               * Requirements:
               *
               * - `target` must be a contract.
               * - calling `target` with `data` must not revert.
               *
               * _Available since v3.1._
               */
              function functionCall(address target, bytes memory data) internal returns (bytes memory) {
                  return functionCallWithValue(target, data, 0, "Address: low-level call failed");
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
               * `errorMessage` as a fallback revert reason when `target` reverts.
               *
               * _Available since v3.1._
               */
              function functionCall(
                  address target,
                  bytes memory data,
                  string memory errorMessage
              ) internal returns (bytes memory) {
                  return functionCallWithValue(target, data, 0, errorMessage);
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
               * but also transferring `value` wei to `target`.
               *
               * Requirements:
               *
               * - the calling contract must have an ETH balance of at least `value`.
               * - the called Solidity function must be `payable`.
               *
               * _Available since v3.1._
               */
              function functionCallWithValue(
                  address target,
                  bytes memory data,
                  uint256 value
              ) internal returns (bytes memory) {
                  return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
              }
              /**
               * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
               * with `errorMessage` as a fallback revert reason when `target` reverts.
               *
               * _Available since v3.1._
               */
              function functionCallWithValue(
                  address target,
                  bytes memory data,
                  uint256 value,
                  string memory errorMessage
              ) internal returns (bytes memory) {
                  require(address(this).balance >= value, "Address: insufficient balance for call");
                  (bool success, bytes memory returndata) = target.call{value: value}(data);
                  return verifyCallResultFromTarget(target, success, returndata, errorMessage);
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
               * but performing a static call.
               *
               * _Available since v3.3._
               */
              function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
                  return functionStaticCall(target, data, "Address: low-level static call failed");
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
               * but performing a static call.
               *
               * _Available since v3.3._
               */
              function functionStaticCall(
                  address target,
                  bytes memory data,
                  string memory errorMessage
              ) internal view returns (bytes memory) {
                  (bool success, bytes memory returndata) = target.staticcall(data);
                  return verifyCallResultFromTarget(target, success, returndata, errorMessage);
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
               * but performing a delegate call.
               *
               * _Available since v3.4._
               */
              function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
                  return functionDelegateCall(target, data, "Address: low-level delegate call failed");
              }
              /**
               * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
               * but performing a delegate call.
               *
               * _Available since v3.4._
               */
              function functionDelegateCall(
                  address target,
                  bytes memory data,
                  string memory errorMessage
              ) internal returns (bytes memory) {
                  (bool success, bytes memory returndata) = target.delegatecall(data);
                  return verifyCallResultFromTarget(target, success, returndata, errorMessage);
              }
              /**
               * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
               * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
               *
               * _Available since v4.8._
               */
              function verifyCallResultFromTarget(
                  address target,
                  bool success,
                  bytes memory returndata,
                  string memory errorMessage
              ) internal view returns (bytes memory) {
                  if (success) {
                      if (returndata.length == 0) {
                          // only check isContract if the call was successful and the return data is empty
                          // otherwise we already know that it was a contract
                          require(isContract(target), "Address: call to non-contract");
                      }
                      return returndata;
                  } else {
                      _revert(returndata, errorMessage);
                  }
              }
              /**
               * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
               * revert reason or using the provided one.
               *
               * _Available since v4.3._
               */
              function verifyCallResult(
                  bool success,
                  bytes memory returndata,
                  string memory errorMessage
              ) internal pure returns (bytes memory) {
                  if (success) {
                      return returndata;
                  } else {
                      _revert(returndata, errorMessage);
                  }
              }
              function _revert(bytes memory returndata, string memory errorMessage) private pure {
                  // Look for revert reason and bubble it up if present
                  if (returndata.length > 0) {
                      // The easiest way to bubble the revert reason is using memory via assembly
                      /// @solidity memory-safe-assembly
                      assembly {
                          let returndata_size := mload(returndata)
                          revert(add(32, returndata), returndata_size)
                      }
                  } else {
                      revert(errorMessage);
                  }
              }
          }
          // SPDX-License-Identifier: UNLICENSED
          pragma solidity 0.8.24;
          import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
          contract RedSnwapper {
            using SafeERC20 for IERC20;
            using Utils for IERC20;
            SafeExecutor public immutable safeExecutor;
            constructor() {
              safeExecutor = new SafeExecutor();
            }
            // @notice Swaps tokens
            // @notice 1. Transfers amountIn of tokens tokenIn to executor
            // @notice 2. launches executor with executorData and value = msg.value
            // @notice 3. Checks that recipient's tokenOut balance was increased at least amountOutMin
            function snwap(
              IERC20 tokenIn,
              uint amountIn, // if amountIn == 0 then amountIn = tokenIn.balance(this) - 1
              address recipient,
              IERC20 tokenOut,
              uint amountOutMin,
              address executor,
              bytes calldata executorData
            ) external payable returns (uint amountOut) {
              uint initialOutputBalance = tokenOut.universalBalanceOf(recipient);
              if (address(tokenIn) != NATIVE_ADDRESS) {
                if (amountIn > 0) tokenIn.safeTransferFrom(msg.sender, executor, amountIn);
                else tokenIn.safeTransfer(executor, tokenIn.balanceOf(address(this)) - 1); // -1 is slot undrain protection
              }
              safeExecutor.execute{value: msg.value}(executor, executorData);
              amountOut = tokenOut.universalBalanceOf(recipient) - initialOutputBalance;
              if (amountOut < amountOutMin)
                revert MinimalOutputBalanceViolation(address(tokenOut), amountOut);
            }
            // @notice Swaps multiple tokens
            // @notice 1. Transfers inputTokens to inputTokens[i].transferTo
            // @notice 2. launches executors
            // @notice 3. Checks that recipient's tokenOut balance was increased at least amountOutMin
            function snwapMultiple(
              InputToken[] calldata inputTokens,
              OutputToken[] calldata outputTokens,
              Executor[] calldata executors
            ) external payable returns (uint[] memory amountOut) {
              uint[] memory initialOutputBalance = new uint[](outputTokens.length);
              for (uint i = 0; i < outputTokens.length; i++) {
                initialOutputBalance[i] = outputTokens[i].token.universalBalanceOf(outputTokens[i].recipient);
              }
              for (uint i = 0; i < inputTokens.length; i++) {
                IERC20 tokenIn = inputTokens[i].token;
                if (address(tokenIn) != NATIVE_ADDRESS) {
                  if (inputTokens[i].amountIn > 0) 
                    tokenIn.safeTransferFrom(msg.sender, inputTokens[i].transferTo, inputTokens[i].amountIn);
                  else tokenIn.safeTransfer(inputTokens[i].transferTo, tokenIn.balanceOf(address(this)) - 1); // -1 is slot undrain protection
                }
              }
              safeExecutor.executeMultiple{value: msg.value}(executors);
              amountOut = new uint[](outputTokens.length);
              for (uint i = 0; i < outputTokens.length; i++) {
                amountOut[i] = outputTokens[i].token.universalBalanceOf(outputTokens[i].recipient) - initialOutputBalance[i];
                if (amountOut[i] < outputTokens[i].amountOutMin)
                  revert MinimalOutputBalanceViolation(address(outputTokens[i].token), amountOut[i]);
              }
            }
          }
          // This contract doesn't have token approves, so can safely call other contracts
          contract SafeExecutor {  
            using Utils for address;
            function execute(address executor, bytes calldata executorData) external payable {
              executor.callRevertBubbleUp(msg.value, executorData);
            }
            function executeMultiple(Executor[] calldata executors) external payable {
              for (uint i = 0; i < executors.length; i++) {
                executors[i].executor.callRevertBubbleUp(executors[i].value, executors[i].data);
              }
            }
          }
          error MinimalOutputBalanceViolation(address tokenOut, uint256 amountOut);
          address constant NATIVE_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
          struct InputToken {
            IERC20 token;
            uint amountIn;
            address transferTo;
          }
          struct OutputToken {
            IERC20 token;
            address recipient;
            uint amountOutMin;
          }
          struct Executor {
            address executor;
            uint value;
            bytes data;
          }
          library Utils {
            using SafeERC20 for IERC20;
            
            function universalBalanceOf(IERC20 token, address user) internal view returns (uint256) {
              if (address(token) == NATIVE_ADDRESS) return address(user).balance;
              else return token.balanceOf(user);
            }
            function callRevertBubbleUp(address contr, uint256 value, bytes memory data) internal {
              (bool success, bytes memory returnBytes) = contr.call{value: value}(data);
              if (!success) {
                assembly {
                  revert(add(32, returnBytes), mload(returnBytes))
                }
              }
            }
          }

          File 2 of 5: Token
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)
          pragma solidity ^0.8.0;
          import "./IERC20.sol";
          import "./extensions/IERC20Metadata.sol";
          import "../../utils/Context.sol";
          /**
           * @dev Implementation of the {IERC20} interface.
           *
           * This implementation is agnostic to the way tokens are created. This means
           * that a supply mechanism has to be added in a derived contract using {_mint}.
           * For a generic mechanism see {ERC20PresetMinterPauser}.
           *
           * TIP: For a detailed writeup see our guide
           * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
           * to implement supply mechanisms].
           *
           * We have followed general OpenZeppelin Contracts guidelines: functions revert
           * instead returning `false` on failure. This behavior is nonetheless
           * conventional and does not conflict with the expectations of ERC20
           * applications.
           *
           * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
           * This allows applications to reconstruct the allowance for all accounts just
           * by listening to said events. Other implementations of the EIP may not emit
           * these events, as it isn't required by the specification.
           *
           * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
           * functions have been added to mitigate the well-known issues around setting
           * allowances. See {IERC20-approve}.
           */
          contract ERC20 is Context, IERC20, IERC20Metadata {
              mapping(address => uint256) private _balances;
              mapping(address => mapping(address => uint256)) private _allowances;
              uint256 private _totalSupply;
              string private _name;
              string private _symbol;
              /**
               * @dev Sets the values for {name} and {symbol}.
               *
               * The default value of {decimals} is 18. To select a different value for
               * {decimals} you should overload it.
               *
               * All two of these values are immutable: they can only be set once during
               * construction.
               */
              constructor(string memory name_, string memory symbol_) {
                  _name = name_;
                  _symbol = symbol_;
              }
              /**
               * @dev Returns the name of the token.
               */
              function name() public view virtual override returns (string memory) {
                  return _name;
              }
              /**
               * @dev Returns the symbol of the token, usually a shorter version of the
               * name.
               */
              function symbol() public view virtual override returns (string memory) {
                  return _symbol;
              }
              /**
               * @dev Returns the number of decimals used to get its user representation.
               * For example, if `decimals` equals `2`, a balance of `505` tokens should
               * be displayed to a user as `5.05` (`505 / 10 ** 2`).
               *
               * Tokens usually opt for a value of 18, imitating the relationship between
               * Ether and Wei. This is the value {ERC20} uses, unless this function is
               * overridden;
               *
               * NOTE: This information is only used for _display_ purposes: it in
               * no way affects any of the arithmetic of the contract, including
               * {IERC20-balanceOf} and {IERC20-transfer}.
               */
              function decimals() public view virtual override returns (uint8) {
                  return 18;
              }
              /**
               * @dev See {IERC20-totalSupply}.
               */
              function totalSupply() public view virtual override returns (uint256) {
                  return _totalSupply;
              }
              /**
               * @dev See {IERC20-balanceOf}.
               */
              function balanceOf(address account) public view virtual override returns (uint256) {
                  return _balances[account];
              }
              /**
               * @dev See {IERC20-transfer}.
               *
               * Requirements:
               *
               * - `to` cannot be the zero address.
               * - the caller must have a balance of at least `amount`.
               */
              function transfer(address to, uint256 amount) public virtual override returns (bool) {
                  address owner = _msgSender();
                  _transfer(owner, to, amount);
                  return true;
              }
              /**
               * @dev See {IERC20-allowance}.
               */
              function allowance(address owner, address spender) public view virtual override returns (uint256) {
                  return _allowances[owner][spender];
              }
              /**
               * @dev See {IERC20-approve}.
               *
               * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
               * `transferFrom`. This is semantically equivalent to an infinite approval.
               *
               * Requirements:
               *
               * - `spender` cannot be the zero address.
               */
              function approve(address spender, uint256 amount) public virtual override returns (bool) {
                  address owner = _msgSender();
                  _approve(owner, spender, amount);
                  return true;
              }
              /**
               * @dev See {IERC20-transferFrom}.
               *
               * Emits an {Approval} event indicating the updated allowance. This is not
               * required by the EIP. See the note at the beginning of {ERC20}.
               *
               * NOTE: Does not update the allowance if the current allowance
               * is the maximum `uint256`.
               *
               * Requirements:
               *
               * - `from` and `to` cannot be the zero address.
               * - `from` must have a balance of at least `amount`.
               * - the caller must have allowance for ``from``'s tokens of at least
               * `amount`.
               */
              function transferFrom(
                  address from,
                  address to,
                  uint256 amount
              ) public virtual override returns (bool) {
                  address spender = _msgSender();
                  _spendAllowance(from, spender, amount);
                  _transfer(from, to, amount);
                  return true;
              }
              /**
               * @dev Atomically increases the allowance granted to `spender` by the caller.
               *
               * This is an alternative to {approve} that can be used as a mitigation for
               * problems described in {IERC20-approve}.
               *
               * Emits an {Approval} event indicating the updated allowance.
               *
               * Requirements:
               *
               * - `spender` cannot be the zero address.
               */
              function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
                  address owner = _msgSender();
                  _approve(owner, spender, allowance(owner, spender) + addedValue);
                  return true;
              }
              /**
               * @dev Atomically decreases the allowance granted to `spender` by the caller.
               *
               * This is an alternative to {approve} that can be used as a mitigation for
               * problems described in {IERC20-approve}.
               *
               * Emits an {Approval} event indicating the updated allowance.
               *
               * Requirements:
               *
               * - `spender` cannot be the zero address.
               * - `spender` must have allowance for the caller of at least
               * `subtractedValue`.
               */
              function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
                  address owner = _msgSender();
                  uint256 currentAllowance = allowance(owner, spender);
                  require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
                  unchecked {
                      _approve(owner, spender, currentAllowance - subtractedValue);
                  }
                  return true;
              }
              /**
               * @dev Moves `amount` of tokens from `from` to `to`.
               *
               * This internal function is equivalent to {transfer}, and can be used to
               * e.g. implement automatic token fees, slashing mechanisms, etc.
               *
               * Emits a {Transfer} event.
               *
               * Requirements:
               *
               * - `from` cannot be the zero address.
               * - `to` cannot be the zero address.
               * - `from` must have a balance of at least `amount`.
               */
              function _transfer(
                  address from,
                  address to,
                  uint256 amount
              ) internal virtual {
                  require(from != address(0), "ERC20: transfer from the zero address");
                  require(to != address(0), "ERC20: transfer to the zero address");
                  _beforeTokenTransfer(from, to, amount);
                  uint256 fromBalance = _balances[from];
                  require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
                  unchecked {
                      _balances[from] = fromBalance - amount;
                      // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
                      // decrementing then incrementing.
                      _balances[to] += amount;
                  }
                  emit Transfer(from, to, amount);
                  _afterTokenTransfer(from, to, amount);
              }
              /** @dev Creates `amount` tokens and assigns them to `account`, increasing
               * the total supply.
               *
               * Emits a {Transfer} event with `from` set to the zero address.
               *
               * Requirements:
               *
               * - `account` cannot be the zero address.
               */
              function _mint(address account, uint256 amount) internal virtual {
                  require(account != address(0), "ERC20: mint to the zero address");
                  _beforeTokenTransfer(address(0), account, amount);
                  _totalSupply += amount;
                  unchecked {
                      // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
                      _balances[account] += amount;
                  }
                  emit Transfer(address(0), account, amount);
                  _afterTokenTransfer(address(0), account, amount);
              }
              /**
               * @dev Destroys `amount` tokens from `account`, reducing the
               * total supply.
               *
               * Emits a {Transfer} event with `to` set to the zero address.
               *
               * Requirements:
               *
               * - `account` cannot be the zero address.
               * - `account` must have at least `amount` tokens.
               */
              function _burn(address account, uint256 amount) internal virtual {
                  require(account != address(0), "ERC20: burn from the zero address");
                  _beforeTokenTransfer(account, address(0), amount);
                  uint256 accountBalance = _balances[account];
                  require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
                  unchecked {
                      _balances[account] = accountBalance - amount;
                      // Overflow not possible: amount <= accountBalance <= totalSupply.
                      _totalSupply -= amount;
                  }
                  emit Transfer(account, address(0), amount);
                  _afterTokenTransfer(account, address(0), amount);
              }
              /**
               * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
               *
               * This internal function is equivalent to `approve`, and can be used to
               * e.g. set automatic allowances for certain subsystems, etc.
               *
               * Emits an {Approval} event.
               *
               * Requirements:
               *
               * - `owner` cannot be the zero address.
               * - `spender` cannot be the zero address.
               */
              function _approve(
                  address owner,
                  address spender,
                  uint256 amount
              ) internal virtual {
                  require(owner != address(0), "ERC20: approve from the zero address");
                  require(spender != address(0), "ERC20: approve to the zero address");
                  _allowances[owner][spender] = amount;
                  emit Approval(owner, spender, amount);
              }
              /**
               * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
               *
               * Does not update the allowance amount in case of infinite allowance.
               * Revert if not enough allowance is available.
               *
               * Might emit an {Approval} event.
               */
              function _spendAllowance(
                  address owner,
                  address spender,
                  uint256 amount
              ) internal virtual {
                  uint256 currentAllowance = allowance(owner, spender);
                  if (currentAllowance != type(uint256).max) {
                      require(currentAllowance >= amount, "ERC20: insufficient allowance");
                      unchecked {
                          _approve(owner, spender, currentAllowance - amount);
                      }
                  }
              }
              /**
               * @dev Hook that is called before any transfer of tokens. This includes
               * minting and burning.
               *
               * Calling conditions:
               *
               * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
               * will be transferred to `to`.
               * - when `from` is zero, `amount` tokens will be minted for `to`.
               * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
               * - `from` and `to` are never both zero.
               *
               * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
               */
              function _beforeTokenTransfer(
                  address from,
                  address to,
                  uint256 amount
              ) internal virtual {}
              /**
               * @dev Hook that is called after any transfer of tokens. This includes
               * minting and burning.
               *
               * Calling conditions:
               *
               * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
               * has been transferred to `to`.
               * - when `from` is zero, `amount` tokens have been minted for `to`.
               * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
               * - `from` and `to` are never both zero.
               *
               * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
               */
              function _afterTokenTransfer(
                  address from,
                  address to,
                  uint256 amount
              ) internal virtual {}
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/ERC20Capped.sol)
          pragma solidity ^0.8.0;
          import "../ERC20.sol";
          /**
           * @dev Extension of {ERC20} that adds a cap to the supply of tokens.
           */
          abstract contract ERC20Capped is ERC20 {
              uint256 private immutable _cap;
              /**
               * @dev Sets the value of the `cap`. This value is immutable, it can only be
               * set once during construction.
               */
              constructor(uint256 cap_) {
                  require(cap_ > 0, "ERC20Capped: cap is 0");
                  _cap = cap_;
              }
              /**
               * @dev Returns the cap on the token's total supply.
               */
              function cap() public view virtual returns (uint256) {
                  return _cap;
              }
              /**
               * @dev See {ERC20-_mint}.
               */
              function _mint(address account, uint256 amount) internal virtual override {
                  require(ERC20.totalSupply() + amount <= cap(), "ERC20Capped: cap exceeded");
                  super._mint(account, amount);
              }
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
          pragma solidity ^0.8.0;
          import "../IERC20.sol";
          /**
           * @dev Interface for the optional metadata functions from the ERC20 standard.
           *
           * _Available since v4.1._
           */
          interface IERC20Metadata is IERC20 {
              /**
               * @dev Returns the name of the token.
               */
              function name() external view returns (string memory);
              /**
               * @dev Returns the symbol of the token.
               */
              function symbol() external view returns (string memory);
              /**
               * @dev Returns the decimals places of the token.
               */
              function decimals() external view returns (uint8);
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
          pragma solidity ^0.8.0;
          /**
           * @dev Interface of the ERC20 standard as defined in the EIP.
           */
          interface IERC20 {
              /**
               * @dev Emitted when `value` tokens are moved from one account (`from`) to
               * another (`to`).
               *
               * Note that `value` may be zero.
               */
              event Transfer(address indexed from, address indexed to, uint256 value);
              /**
               * @dev Emitted when the allowance of a `spender` for an `owner` is set by
               * a call to {approve}. `value` is the new allowance.
               */
              event Approval(address indexed owner, address indexed spender, uint256 value);
              /**
               * @dev Returns the 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 `to`.
               *
               * Returns a boolean value indicating whether the operation succeeded.
               *
               * Emits a {Transfer} event.
               */
              function transfer(address to, uint256 amount) external returns (bool);
              /**
               * @dev Returns the remaining number of tokens that `spender` will be
               * allowed to spend on behalf of `owner` through {transferFrom}. This is
               * zero by default.
               *
               * This value changes when {approve} or {transferFrom} are called.
               */
              function allowance(address owner, address spender) external view returns (uint256);
              /**
               * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
               *
               * Returns a boolean value indicating whether the operation succeeded.
               *
               * IMPORTANT: Beware that changing an allowance with this method brings the risk
               * that someone may use both the old and the new allowance by unfortunate
               * transaction ordering. One possible solution to mitigate this race
               * condition is to first reduce the spender's allowance to 0 and set the
               * desired value afterwards:
               * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
               *
               * Emits an {Approval} event.
               */
              function approve(address spender, uint256 amount) external returns (bool);
              /**
               * @dev Moves `amount` tokens from `from` to `to` 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 from,
                  address to,
                  uint256 amount
              ) external returns (bool);
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
          pragma solidity ^0.8.0;
          /**
           * @dev Provides information about the current execution context, including the
           * sender of the transaction and its data. While these are generally available
           * via msg.sender and msg.data, they should not be accessed in such a direct
           * manner, since when dealing with meta-transactions the account sending and
           * paying for execution may not be the actual sender (as far as an application
           * is concerned).
           *
           * This contract is only required for intermediate, library-like contracts.
           */
          abstract contract Context {
              function _msgSender() internal view virtual returns (address) {
                  return msg.sender;
              }
              function _msgData() internal view virtual returns (bytes calldata) {
                  return msg.data;
              }
          }
          // SPDX-License-Identifier: MIT
          pragma solidity 0.8.16;
          import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol";
          contract Token is ERC20Capped {
              uint8 private immutable customDecimals;
              constructor(
                  string memory _erc20Name,
                  string memory _erc20Symbol,
                  uint8 _decimals,
                  uint256 _cap,
                  address[] memory _mintAddresses,
                  uint256[] memory _mintAmounts
              ) ERC20(_erc20Name, _erc20Symbol) ERC20Capped(_cap) {
                  require(_mintAddresses.length == _mintAmounts.length, "must have same number of mint addresses and amounts");
                  customDecimals = _decimals;
                  for (uint i; i < _mintAddresses.length; i++) {
                      require(_mintAddresses[i] != address(0), "cannot have a non-address as reserve");
                      ERC20._mint(_mintAddresses[i], _mintAmounts[i]);
                  }
                  require(_cap >= totalSupply(), "total supply of tokens cannot exceed the cap");
              }
              function decimals() public view override returns (uint8) {
                  return customDecimals;
              }
          }
          

          File 3 of 5: PancakePair
          /**
           *Submitted for verification at BscScan.com on 2021-04-23
          */
          /**
           *Submitted for verification at BscScan.com on 2021-04-22
          */
          /**
           *Submitted for verification at BscScan.com on 2021-04-22
          */
          /**
           *Submitted for verification at BscScan.com on 2020-09-19
          */
          pragma solidity =0.5.16;
          interface IPancakeFactory {
              event PairCreated(address indexed token0, address indexed token1, address pair, uint);
              function feeTo() external view returns (address);
              function feeToSetter() external view returns (address);
              function getPair(address tokenA, address tokenB) external view returns (address pair);
              function allPairs(uint) external view returns (address pair);
              function allPairsLength() external view returns (uint);
              function createPair(address tokenA, address tokenB) external returns (address pair);
              function setFeeTo(address) external;
              function setFeeToSetter(address) external;
          }
          interface IPancakePair {
              event Approval(address indexed owner, address indexed spender, uint value);
              event Transfer(address indexed from, address indexed to, uint value);
              function name() external pure returns (string memory);
              function symbol() external pure returns (string memory);
              function decimals() external pure returns (uint8);
              function totalSupply() external view returns (uint);
              function balanceOf(address owner) external view returns (uint);
              function allowance(address owner, address spender) external view returns (uint);
              function approve(address spender, uint value) external returns (bool);
              function transfer(address to, uint value) external returns (bool);
              function transferFrom(address from, address to, uint value) external returns (bool);
              function DOMAIN_SEPARATOR() external view returns (bytes32);
              function PERMIT_TYPEHASH() external pure returns (bytes32);
              function nonces(address owner) external view returns (uint);
              function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
              event Mint(address indexed sender, uint amount0, uint amount1);
              event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
              event Swap(
                  address indexed sender,
                  uint amount0In,
                  uint amount1In,
                  uint amount0Out,
                  uint amount1Out,
                  address indexed to
              );
              event Sync(uint112 reserve0, uint112 reserve1);
              function MINIMUM_LIQUIDITY() external pure returns (uint);
              function factory() external view returns (address);
              function token0() external view returns (address);
              function token1() external view returns (address);
              function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
              function price0CumulativeLast() external view returns (uint);
              function price1CumulativeLast() external view returns (uint);
              function kLast() external view returns (uint);
              function mint(address to) external returns (uint liquidity);
              function burn(address to) external returns (uint amount0, uint amount1);
              function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
              function skim(address to) external;
              function sync() external;
              function initialize(address, address) external;
          }
          interface IPancakeERC20 {
              event Approval(address indexed owner, address indexed spender, uint value);
              event Transfer(address indexed from, address indexed to, uint value);
              function name() external pure returns (string memory);
              function symbol() external pure returns (string memory);
              function decimals() external pure returns (uint8);
              function totalSupply() external view returns (uint);
              function balanceOf(address owner) external view returns (uint);
              function allowance(address owner, address spender) external view returns (uint);
              function approve(address spender, uint value) external returns (bool);
              function transfer(address to, uint value) external returns (bool);
              function transferFrom(address from, address to, uint value) external returns (bool);
              function DOMAIN_SEPARATOR() external view returns (bytes32);
              function PERMIT_TYPEHASH() external pure returns (bytes32);
              function nonces(address owner) external view returns (uint);
              function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
          }
          // a library for performing overflow-safe math, courtesy of DappHub (https://github.com/dapphub/ds-math)
          library SafeMath {
              function add(uint x, uint y) internal pure returns (uint z) {
                  require((z = x + y) >= x, 'ds-math-add-overflow');
              }
              function sub(uint x, uint y) internal pure returns (uint z) {
                  require((z = x - y) <= x, 'ds-math-sub-underflow');
              }
              function mul(uint x, uint y) internal pure returns (uint z) {
                  require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
              }
          }
          contract PancakeERC20 is IPancakeERC20 {
              using SafeMath for uint;
              string public constant name = 'Pancake LPs';
              string public constant symbol = 'Cake-LP';
              uint8 public constant decimals = 18;
              uint  public totalSupply;
              mapping(address => uint) public balanceOf;
              mapping(address => mapping(address => uint)) public allowance;
              bytes32 public DOMAIN_SEPARATOR;
              // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
              bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
              mapping(address => uint) public nonces;
              event Approval(address indexed owner, address indexed spender, uint value);
              event Transfer(address indexed from, address indexed to, uint value);
              constructor() public {
                  uint chainId;
                  assembly {
                      chainId := chainid
                  }
                  DOMAIN_SEPARATOR = keccak256(
                      abi.encode(
                          keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
                          keccak256(bytes(name)),
                          keccak256(bytes('1')),
                          chainId,
                          address(this)
                      )
                  );
              }
              function _mint(address to, uint value) internal {
                  totalSupply = totalSupply.add(value);
                  balanceOf[to] = balanceOf[to].add(value);
                  emit Transfer(address(0), to, value);
              }
              function _burn(address from, uint value) internal {
                  balanceOf[from] = balanceOf[from].sub(value);
                  totalSupply = totalSupply.sub(value);
                  emit Transfer(from, address(0), value);
              }
              function _approve(address owner, address spender, uint value) private {
                  allowance[owner][spender] = value;
                  emit Approval(owner, spender, value);
              }
              function _transfer(address from, address to, uint value) private {
                  balanceOf[from] = balanceOf[from].sub(value);
                  balanceOf[to] = balanceOf[to].add(value);
                  emit Transfer(from, to, value);
              }
              function approve(address spender, uint value) external returns (bool) {
                  _approve(msg.sender, spender, value);
                  return true;
              }
              function transfer(address to, uint value) external returns (bool) {
                  _transfer(msg.sender, to, value);
                  return true;
              }
              function transferFrom(address from, address to, uint value) external returns (bool) {
                  if (allowance[from][msg.sender] != uint(-1)) {
                      allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
                  }
                  _transfer(from, to, value);
                  return true;
              }
              function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
                  require(deadline >= block.timestamp, 'Pancake: EXPIRED');
                  bytes32 digest = keccak256(
                      abi.encodePacked(
                          '\\x19\\x01',
                          DOMAIN_SEPARATOR,
                          keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))
                      )
                  );
                  address recoveredAddress = ecrecover(digest, v, r, s);
                  require(recoveredAddress != address(0) && recoveredAddress == owner, 'Pancake: INVALID_SIGNATURE');
                  _approve(owner, spender, value);
              }
          }
          // a library for performing various math operations
          library Math {
              function min(uint x, uint y) internal pure returns (uint z) {
                  z = x < y ? x : y;
              }
              // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
              function sqrt(uint y) internal pure returns (uint z) {
                  if (y > 3) {
                      z = y;
                      uint x = y / 2 + 1;
                      while (x < z) {
                          z = x;
                          x = (y / x + x) / 2;
                      }
                  } else if (y != 0) {
                      z = 1;
                  }
              }
          }
          // a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))
          // range: [0, 2**112 - 1]
          // resolution: 1 / 2**112
          library UQ112x112 {
              uint224 constant Q112 = 2**112;
              // encode a uint112 as a UQ112x112
              function encode(uint112 y) internal pure returns (uint224 z) {
                  z = uint224(y) * Q112; // never overflows
              }
              // divide a UQ112x112 by a uint112, returning a UQ112x112
              function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
                  z = x / uint224(y);
              }
          }
          interface IERC20 {
              event Approval(address indexed owner, address indexed spender, uint value);
              event Transfer(address indexed from, address indexed to, uint value);
              function name() external view returns (string memory);
              function symbol() external view returns (string memory);
              function decimals() external view returns (uint8);
              function totalSupply() external view returns (uint);
              function balanceOf(address owner) external view returns (uint);
              function allowance(address owner, address spender) external view returns (uint);
              function approve(address spender, uint value) external returns (bool);
              function transfer(address to, uint value) external returns (bool);
              function transferFrom(address from, address to, uint value) external returns (bool);
          }
          interface IPancakeCallee {
              function pancakeCall(address sender, uint amount0, uint amount1, bytes calldata data) external;
          }
          contract PancakePair is IPancakePair, PancakeERC20 {
              using SafeMath  for uint;
              using UQ112x112 for uint224;
              uint public constant MINIMUM_LIQUIDITY = 10**3;
              bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
              address public factory;
              address public token0;
              address public token1;
              uint112 private reserve0;           // uses single storage slot, accessible via getReserves
              uint112 private reserve1;           // uses single storage slot, accessible via getReserves
              uint32  private blockTimestampLast; // uses single storage slot, accessible via getReserves
              uint public price0CumulativeLast;
              uint public price1CumulativeLast;
              uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
              uint private unlocked = 1;
              modifier lock() {
                  require(unlocked == 1, 'Pancake: LOCKED');
                  unlocked = 0;
                  _;
                  unlocked = 1;
              }
              function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
                  _reserve0 = reserve0;
                  _reserve1 = reserve1;
                  _blockTimestampLast = blockTimestampLast;
              }
              function _safeTransfer(address token, address to, uint value) private {
                  (bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
                  require(success && (data.length == 0 || abi.decode(data, (bool))), 'Pancake: TRANSFER_FAILED');
              }
              event Mint(address indexed sender, uint amount0, uint amount1);
              event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
              event Swap(
                  address indexed sender,
                  uint amount0In,
                  uint amount1In,
                  uint amount0Out,
                  uint amount1Out,
                  address indexed to
              );
              event Sync(uint112 reserve0, uint112 reserve1);
              constructor() public {
                  factory = msg.sender;
              }
              // called once by the factory at time of deployment
              function initialize(address _token0, address _token1) external {
                  require(msg.sender == factory, 'Pancake: FORBIDDEN'); // sufficient check
                  token0 = _token0;
                  token1 = _token1;
              }
              // update reserves and, on the first call per block, price accumulators
              function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
                  require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'Pancake: OVERFLOW');
                  uint32 blockTimestamp = uint32(block.timestamp % 2**32);
                  uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
                  if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
                      // * never overflows, and + overflow is desired
                      price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
                      price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
                  }
                  reserve0 = uint112(balance0);
                  reserve1 = uint112(balance1);
                  blockTimestampLast = blockTimestamp;
                  emit Sync(reserve0, reserve1);
              }
              // if fee is on, mint liquidity equivalent to 8/25 of the growth in sqrt(k)
              function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
                  address feeTo = IPancakeFactory(factory).feeTo();
                  feeOn = feeTo != address(0);
                  uint _kLast = kLast; // gas savings
                  if (feeOn) {
                      if (_kLast != 0) {
                          uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
                          uint rootKLast = Math.sqrt(_kLast);
                          if (rootK > rootKLast) {
                              uint numerator = totalSupply.mul(rootK.sub(rootKLast)).mul(8);
                              uint denominator = rootK.mul(17).add(rootKLast.mul(8));
                              uint liquidity = numerator / denominator;
                              if (liquidity > 0) _mint(feeTo, liquidity);
                          }
                      }
                  } else if (_kLast != 0) {
                      kLast = 0;
                  }
              }
              // this low-level function should be called from a contract which performs important safety checks
              function mint(address to) external lock returns (uint liquidity) {
                  (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
                  uint balance0 = IERC20(token0).balanceOf(address(this));
                  uint balance1 = IERC20(token1).balanceOf(address(this));
                  uint amount0 = balance0.sub(_reserve0);
                  uint amount1 = balance1.sub(_reserve1);
                  bool feeOn = _mintFee(_reserve0, _reserve1);
                  uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
                  if (_totalSupply == 0) {
                      liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
                      _mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
                  } else {
                      liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
                  }
                  require(liquidity > 0, 'Pancake: INSUFFICIENT_LIQUIDITY_MINTED');
                  _mint(to, liquidity);
                  _update(balance0, balance1, _reserve0, _reserve1);
                  if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
                  emit Mint(msg.sender, amount0, amount1);
              }
              // this low-level function should be called from a contract which performs important safety checks
              function burn(address to) external lock returns (uint amount0, uint amount1) {
                  (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
                  address _token0 = token0;                                // gas savings
                  address _token1 = token1;                                // gas savings
                  uint balance0 = IERC20(_token0).balanceOf(address(this));
                  uint balance1 = IERC20(_token1).balanceOf(address(this));
                  uint liquidity = balanceOf[address(this)];
                  bool feeOn = _mintFee(_reserve0, _reserve1);
                  uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
                  amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
                  amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
                  require(amount0 > 0 && amount1 > 0, 'Pancake: INSUFFICIENT_LIQUIDITY_BURNED');
                  _burn(address(this), liquidity);
                  _safeTransfer(_token0, to, amount0);
                  _safeTransfer(_token1, to, amount1);
                  balance0 = IERC20(_token0).balanceOf(address(this));
                  balance1 = IERC20(_token1).balanceOf(address(this));
                  _update(balance0, balance1, _reserve0, _reserve1);
                  if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
                  emit Burn(msg.sender, amount0, amount1, to);
              }
              // this low-level function should be called from a contract which performs important safety checks
              function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
                  require(amount0Out > 0 || amount1Out > 0, 'Pancake: INSUFFICIENT_OUTPUT_AMOUNT');
                  (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
                  require(amount0Out < _reserve0 && amount1Out < _reserve1, 'Pancake: INSUFFICIENT_LIQUIDITY');
                  uint balance0;
                  uint balance1;
                  { // scope for _token{0,1}, avoids stack too deep errors
                      address _token0 = token0;
                      address _token1 = token1;
                      require(to != _token0 && to != _token1, 'Pancake: INVALID_TO');
                      if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
                      if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
                      if (data.length > 0) IPancakeCallee(to).pancakeCall(msg.sender, amount0Out, amount1Out, data);
                      balance0 = IERC20(_token0).balanceOf(address(this));
                      balance1 = IERC20(_token1).balanceOf(address(this));
                  }
                  uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
                  uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
                  require(amount0In > 0 || amount1In > 0, 'Pancake: INSUFFICIENT_INPUT_AMOUNT');
                  { // scope for reserve{0,1}Adjusted, avoids stack too deep errors
                      uint balance0Adjusted = (balance0.mul(10000).sub(amount0In.mul(25)));
                      uint balance1Adjusted = (balance1.mul(10000).sub(amount1In.mul(25)));
                      require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(10000**2), 'Pancake: K');
                  }
                  _update(balance0, balance1, _reserve0, _reserve1);
                  emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
              }
              // force balances to match reserves
              function skim(address to) external lock {
                  address _token0 = token0; // gas savings
                  address _token1 = token1; // gas savings
                  _safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0));
                  _safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1));
              }
              // force reserves to match balances
              function sync() external lock {
                  _update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
              }
          }
          contract PancakeFactory is IPancakeFactory {
              bytes32 public constant INIT_CODE_PAIR_HASH = keccak256(abi.encodePacked(type(PancakePair).creationCode));
              address public feeTo;
              address public feeToSetter;
              mapping(address => mapping(address => address)) public getPair;
              address[] public allPairs;
              event PairCreated(address indexed token0, address indexed token1, address pair, uint);
              constructor(address _feeToSetter) public {
                  feeToSetter = _feeToSetter;
              }
              function allPairsLength() external view returns (uint) {
                  return allPairs.length;
              }
              function createPair(address tokenA, address tokenB) external returns (address pair) {
                  require(tokenA != tokenB, 'Pancake: IDENTICAL_ADDRESSES');
                  (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
                  require(token0 != address(0), 'Pancake: ZERO_ADDRESS');
                  require(getPair[token0][token1] == address(0), 'Pancake: PAIR_EXISTS'); // single check is sufficient
                  bytes memory bytecode = type(PancakePair).creationCode;
                  bytes32 salt = keccak256(abi.encodePacked(token0, token1));
                  assembly {
                      pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
                  }
                  IPancakePair(pair).initialize(token0, token1);
                  getPair[token0][token1] = pair;
                  getPair[token1][token0] = pair; // populate mapping in the reverse direction
                  allPairs.push(pair);
                  emit PairCreated(token0, token1, pair, allPairs.length);
              }
              function setFeeTo(address _feeTo) external {
                  require(msg.sender == feeToSetter, 'Pancake: FORBIDDEN');
                  feeTo = _feeTo;
              }
              function setFeeToSetter(address _feeToSetter) external {
                  require(msg.sender == feeToSetter, 'Pancake: FORBIDDEN');
                  feeToSetter = _feeToSetter;
              }
          }

          File 4 of 5: TetherToken
          pragma solidity ^0.4.17;
          
          /**
           * @title SafeMath
           * @dev Math operations with safety checks that throw on error
           */
          library SafeMath {
              function mul(uint256 a, uint256 b) internal pure returns (uint256) {
                  if (a == 0) {
                      return 0;
                  }
                  uint256 c = a * b;
                  assert(c / a == b);
                  return c;
              }
          
              function div(uint256 a, uint256 b) internal pure returns (uint256) {
                  // assert(b > 0); // Solidity automatically throws when dividing by 0
                  uint256 c = a / b;
                  // assert(a == b * c + a % b); // There is no case in which this doesn't hold
                  return c;
              }
          
              function sub(uint256 a, uint256 b) internal pure returns (uint256) {
                  assert(b <= a);
                  return a - b;
              }
          
              function add(uint256 a, uint256 b) internal pure returns (uint256) {
                  uint256 c = a + b;
                  assert(c >= a);
                  return c;
              }
          }
          
          /**
           * @title Ownable
           * @dev The Ownable contract has an owner address, and provides basic authorization control
           * functions, this simplifies the implementation of "user permissions".
           */
          contract Ownable {
              address public owner;
          
              /**
                * @dev The Ownable constructor sets the original `owner` of the contract to the sender
                * account.
                */
              function Ownable() public {
                  owner = msg.sender;
              }
          
              /**
                * @dev Throws if called by any account other than the owner.
                */
              modifier onlyOwner() {
                  require(msg.sender == owner);
                  _;
              }
          
              /**
              * @dev Allows the current owner to transfer control of the contract to a newOwner.
              * @param newOwner The address to transfer ownership to.
              */
              function transferOwnership(address newOwner) public onlyOwner {
                  if (newOwner != address(0)) {
                      owner = newOwner;
                  }
              }
          
          }
          
          /**
           * @title ERC20Basic
           * @dev Simpler version of ERC20 interface
           * @dev see https://github.com/ethereum/EIPs/issues/20
           */
          contract ERC20Basic {
              uint public _totalSupply;
              function totalSupply() public constant returns (uint);
              function balanceOf(address who) public constant returns (uint);
              function transfer(address to, uint value) public;
              event Transfer(address indexed from, address indexed to, uint value);
          }
          
          /**
           * @title ERC20 interface
           * @dev see https://github.com/ethereum/EIPs/issues/20
           */
          contract ERC20 is ERC20Basic {
              function allowance(address owner, address spender) public constant returns (uint);
              function transferFrom(address from, address to, uint value) public;
              function approve(address spender, uint value) public;
              event Approval(address indexed owner, address indexed spender, uint value);
          }
          
          /**
           * @title Basic token
           * @dev Basic version of StandardToken, with no allowances.
           */
          contract BasicToken is Ownable, ERC20Basic {
              using SafeMath for uint;
          
              mapping(address => uint) public balances;
          
              // additional variables for use if transaction fees ever became necessary
              uint public basisPointsRate = 0;
              uint public maximumFee = 0;
          
              /**
              * @dev Fix for the ERC20 short address attack.
              */
              modifier onlyPayloadSize(uint size) {
                  require(!(msg.data.length < size + 4));
                  _;
              }
          
              /**
              * @dev transfer token for a specified address
              * @param _to The address to transfer to.
              * @param _value The amount to be transferred.
              */
              function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) {
                  uint fee = (_value.mul(basisPointsRate)).div(10000);
                  if (fee > maximumFee) {
                      fee = maximumFee;
                  }
                  uint sendAmount = _value.sub(fee);
                  balances[msg.sender] = balances[msg.sender].sub(_value);
                  balances[_to] = balances[_to].add(sendAmount);
                  if (fee > 0) {
                      balances[owner] = balances[owner].add(fee);
                      Transfer(msg.sender, owner, fee);
                  }
                  Transfer(msg.sender, _to, sendAmount);
              }
          
              /**
              * @dev Gets the balance of the specified address.
              * @param _owner The address to query the the balance of.
              * @return An uint representing the amount owned by the passed address.
              */
              function balanceOf(address _owner) public constant returns (uint balance) {
                  return balances[_owner];
              }
          
          }
          
          /**
           * @title Standard ERC20 token
           *
           * @dev Implementation of the basic standard token.
           * @dev https://github.com/ethereum/EIPs/issues/20
           * @dev Based oncode by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
           */
          contract StandardToken is BasicToken, ERC20 {
          
              mapping (address => mapping (address => uint)) public allowed;
          
              uint public constant MAX_UINT = 2**256 - 1;
          
              /**
              * @dev Transfer tokens from one address to another
              * @param _from address The address which you want to send tokens from
              * @param _to address The address which you want to transfer to
              * @param _value uint the amount of tokens to be transferred
              */
              function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) {
                  var _allowance = allowed[_from][msg.sender];
          
                  // Check is not needed because sub(_allowance, _value) will already throw if this condition is not met
                  // if (_value > _allowance) throw;
          
                  uint fee = (_value.mul(basisPointsRate)).div(10000);
                  if (fee > maximumFee) {
                      fee = maximumFee;
                  }
                  if (_allowance < MAX_UINT) {
                      allowed[_from][msg.sender] = _allowance.sub(_value);
                  }
                  uint sendAmount = _value.sub(fee);
                  balances[_from] = balances[_from].sub(_value);
                  balances[_to] = balances[_to].add(sendAmount);
                  if (fee > 0) {
                      balances[owner] = balances[owner].add(fee);
                      Transfer(_from, owner, fee);
                  }
                  Transfer(_from, _to, sendAmount);
              }
          
              /**
              * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
              * @param _spender The address which will spend the funds.
              * @param _value The amount of tokens to be spent.
              */
              function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
          
                  // To change the approve amount you first have to reduce the addresses`
                  //  allowance to zero by calling `approve(_spender, 0)` if it is not
                  //  already 0 to mitigate the race condition described here:
                  //  https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
                  require(!((_value != 0) && (allowed[msg.sender][_spender] != 0)));
          
                  allowed[msg.sender][_spender] = _value;
                  Approval(msg.sender, _spender, _value);
              }
          
              /**
              * @dev Function to check the amount of tokens than an owner allowed to a spender.
              * @param _owner address The address which owns the funds.
              * @param _spender address The address which will spend the funds.
              * @return A uint specifying the amount of tokens still available for the spender.
              */
              function allowance(address _owner, address _spender) public constant returns (uint remaining) {
                  return allowed[_owner][_spender];
              }
          
          }
          
          
          /**
           * @title Pausable
           * @dev Base contract which allows children to implement an emergency stop mechanism.
           */
          contract Pausable is Ownable {
            event Pause();
            event Unpause();
          
            bool public paused = false;
          
          
            /**
             * @dev Modifier to make a function callable only when the contract is not paused.
             */
            modifier whenNotPaused() {
              require(!paused);
              _;
            }
          
            /**
             * @dev Modifier to make a function callable only when the contract is paused.
             */
            modifier whenPaused() {
              require(paused);
              _;
            }
          
            /**
             * @dev called by the owner to pause, triggers stopped state
             */
            function pause() onlyOwner whenNotPaused public {
              paused = true;
              Pause();
            }
          
            /**
             * @dev called by the owner to unpause, returns to normal state
             */
            function unpause() onlyOwner whenPaused public {
              paused = false;
              Unpause();
            }
          }
          
          contract BlackList is Ownable, BasicToken {
          
              /////// Getters to allow the same blacklist to be used also by other contracts (including upgraded Tether) ///////
              function getBlackListStatus(address _maker) external constant returns (bool) {
                  return isBlackListed[_maker];
              }
          
              function getOwner() external constant returns (address) {
                  return owner;
              }
          
              mapping (address => bool) public isBlackListed;
              
              function addBlackList (address _evilUser) public onlyOwner {
                  isBlackListed[_evilUser] = true;
                  AddedBlackList(_evilUser);
              }
          
              function removeBlackList (address _clearedUser) public onlyOwner {
                  isBlackListed[_clearedUser] = false;
                  RemovedBlackList(_clearedUser);
              }
          
              function destroyBlackFunds (address _blackListedUser) public onlyOwner {
                  require(isBlackListed[_blackListedUser]);
                  uint dirtyFunds = balanceOf(_blackListedUser);
                  balances[_blackListedUser] = 0;
                  _totalSupply -= dirtyFunds;
                  DestroyedBlackFunds(_blackListedUser, dirtyFunds);
              }
          
              event DestroyedBlackFunds(address _blackListedUser, uint _balance);
          
              event AddedBlackList(address _user);
          
              event RemovedBlackList(address _user);
          
          }
          
          contract UpgradedStandardToken is StandardToken{
              // those methods are called by the legacy contract
              // and they must ensure msg.sender to be the contract address
              function transferByLegacy(address from, address to, uint value) public;
              function transferFromByLegacy(address sender, address from, address spender, uint value) public;
              function approveByLegacy(address from, address spender, uint value) public;
          }
          
          contract TetherToken is Pausable, StandardToken, BlackList {
          
              string public name;
              string public symbol;
              uint public decimals;
              address public upgradedAddress;
              bool public deprecated;
          
              //  The contract can be initialized with a number of tokens
              //  All the tokens are deposited to the owner address
              //
              // @param _balance Initial supply of the contract
              // @param _name Token Name
              // @param _symbol Token symbol
              // @param _decimals Token decimals
              function TetherToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public {
                  _totalSupply = _initialSupply;
                  name = _name;
                  symbol = _symbol;
                  decimals = _decimals;
                  balances[owner] = _initialSupply;
                  deprecated = false;
              }
          
              // Forward ERC20 methods to upgraded contract if this one is deprecated
              function transfer(address _to, uint _value) public whenNotPaused {
                  require(!isBlackListed[msg.sender]);
                  if (deprecated) {
                      return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
                  } else {
                      return super.transfer(_to, _value);
                  }
              }
          
              // Forward ERC20 methods to upgraded contract if this one is deprecated
              function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
                  require(!isBlackListed[_from]);
                  if (deprecated) {
                      return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
                  } else {
                      return super.transferFrom(_from, _to, _value);
                  }
              }
          
              // Forward ERC20 methods to upgraded contract if this one is deprecated
              function balanceOf(address who) public constant returns (uint) {
                  if (deprecated) {
                      return UpgradedStandardToken(upgradedAddress).balanceOf(who);
                  } else {
                      return super.balanceOf(who);
                  }
              }
          
              // Forward ERC20 methods to upgraded contract if this one is deprecated
              function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) {
                  if (deprecated) {
                      return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
                  } else {
                      return super.approve(_spender, _value);
                  }
              }
          
              // Forward ERC20 methods to upgraded contract if this one is deprecated
              function allowance(address _owner, address _spender) public constant returns (uint remaining) {
                  if (deprecated) {
                      return StandardToken(upgradedAddress).allowance(_owner, _spender);
                  } else {
                      return super.allowance(_owner, _spender);
                  }
              }
          
              // deprecate current contract in favour of a new one
              function deprecate(address _upgradedAddress) public onlyOwner {
                  deprecated = true;
                  upgradedAddress = _upgradedAddress;
                  Deprecate(_upgradedAddress);
              }
          
              // deprecate current contract if favour of a new one
              function totalSupply() public constant returns (uint) {
                  if (deprecated) {
                      return StandardToken(upgradedAddress).totalSupply();
                  } else {
                      return _totalSupply;
                  }
              }
          
              // Issue a new amount of tokens
              // these tokens are deposited into the owner address
              //
              // @param _amount Number of tokens to be issued
              function issue(uint amount) public onlyOwner {
                  require(_totalSupply + amount > _totalSupply);
                  require(balances[owner] + amount > balances[owner]);
          
                  balances[owner] += amount;
                  _totalSupply += amount;
                  Issue(amount);
              }
          
              // Redeem tokens.
              // These tokens are withdrawn from the owner address
              // if the balance must be enough to cover the redeem
              // or the call will fail.
              // @param _amount Number of tokens to be issued
              function redeem(uint amount) public onlyOwner {
                  require(_totalSupply >= amount);
                  require(balances[owner] >= amount);
          
                  _totalSupply -= amount;
                  balances[owner] -= amount;
                  Redeem(amount);
              }
          
              function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
                  // Ensure transparency by hardcoding limit beyond which fees can never be added
                  require(newBasisPoints < 20);
                  require(newMaxFee < 50);
          
                  basisPointsRate = newBasisPoints;
                  maximumFee = newMaxFee.mul(10**decimals);
          
                  Params(basisPointsRate, maximumFee);
              }
          
              // Called when new token are issued
              event Issue(uint amount);
          
              // Called when tokens are redeemed
              event Redeem(uint amount);
          
              // Called when contract is deprecated
              event Deprecate(address newAddress);
          
              // Called if contract ever adds fees
              event Params(uint feeBasisPoints, uint maxFee);
          }

          File 5 of 5: TokenChomper
          // SPDX-License-Identifier: GPL-3.0-or-later
          pragma solidity >=0.8.0;
          import "/interfaces/IRouteProcessor.sol";
          import "interfaces/IERC20.sol";
          import "./Auth.sol";
          /// @title TokenChomper for selling accumulated tokens for weth or other base assets
          /// @notice This contract will be used for fee collection and breakdown
          /// @dev Uses Auth contract for 2-step owner process and trust operators to guard functions
          contract TokenChomper is Auth {
            address public immutable weth;
            IRouteProcessor public routeProcessor;
            bytes4 private constant TRANSFER_SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
            error TransferFailed();
            constructor(
              address _operator,
              address _routeProcessor,
              address _weth
            ) Auth(_operator) {
              // initial owner is msg.sender
              routeProcessor = IRouteProcessor(_routeProcessor);
              weth = _weth;
            }
            /// @notice Updates the route processor to be used for swapping tokens
            /// @dev make sure new route processor is backwards compatiable (should be)
            /// @param _routeProcessor The address of the new route processor
            function updateRouteProcessor(address _routeProcessor) external onlyOwner {
              routeProcessor = IRouteProcessor(_routeProcessor);
            }
            
            /// @notice Processes a route selling any of the tokens in TokenChomper for an output token
            /// @dev can be called by operators
            /// @param tokenIn The address of the token to be sold
            /// @param amountIn The amount of the token to be sold
            /// @param tokenOut The address of the token to be bought
            /// @param amoutOutMin The minimum amount of the token to be bought (slippage protection)
            /// @param route The route to be used for swapping
            function processRoute(
              address tokenIn,
              uint256 amountIn,
              address tokenOut,
              uint256 amoutOutMin,
              bytes memory route
            ) external onlyTrusted {
              // process route to any output token, slippage will be handled by the route processor
              IERC20(tokenIn).transfer(address(routeProcessor), amountIn);
              routeProcessor.processRoute(
                tokenIn, amountIn, tokenOut, amoutOutMin, address(this), route
              ); 
            }
            /// @notice Withdraw any token or eth from the contract
            /// @dev can only be called by owner
            /// @param token The address of the token to be withdrawn, 0x0 for eth
            /// @param to The address to send the token to
            /// @param _value The amount of the token to be withdrawn
            function withdraw(address token, address to, uint256 _value) onlyOwner external {
              if (token != address(0)) {
                _safeTransfer(token, to, _value);
              } 
              else {
                (bool success, ) = to.call{value: _value}("");
                require(success);
              }
            }
            
            function _safeTransfer(address token, address to, uint value) internal {
              (bool success, bytes memory data) = token.call(abi.encodeWithSelector(TRANSFER_SELECTOR, to, value));
              if (!success || (data.length != 0 && !abi.decode(data, (bool)))) revert TransferFailed();
            }
            /// @notice In case we receive any unwrapped eth (native token) we can call this
            /// @dev operators can call this 
            function wrapEth() onlyTrusted external {
              weth.call{value: address(this).balance}("");
            }
            /// @notice Available function in case we need to do any calls that aren't supported by the contract (unwinding lp positions, etc.)
            /// @dev can only be called by owner
            /// @param to The address to send the call to
            /// @param _value The amount of eth to send with the call
            /// @param data The data to be sent with the call
            function doAction(address to, uint256 _value, bytes memory data) onlyOwner external {
              (bool success, ) = to.call{value: _value}(data);
              require(success);
            }
            receive() external payable {}
          }// SPDX-License-Identifier: GPL-3.0-or-later
          pragma solidity >= 0.8.0;
          interface IRouteProcessor {
            
            struct RouteProcessorData {
                  address tokenIn;
                  uint256 amountIn;
                  address tokenOut;
                  uint256 amountOutMin;
                  address to;
                  bytes route;
            }
            
            function processRoute(
              address tokenIn,
              uint256 amountIn,
              address tokenOut,
              uint256 amountOutMin,
              address to,
              bytes memory route
            ) external payable returns (uint256 amountOut);
          }// SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)
          pragma solidity >= 0.8.0;
          /**
           * @dev Interface of the ERC20 standard as defined in the EIP.
           */
          interface IERC20 {
              /**
               * @dev Emitted when `value` tokens are moved from one account (`from`) to
               * another (`to`).
               *
               * Note that `value` may be zero.
               */
              event Transfer(address indexed from, address indexed to, uint256 value);
              /**
               * @dev Emitted when the allowance of a `spender` for an `owner` is set by
               * a call to {approve}. `value` is the new allowance.
               */
              event Approval(address indexed owner, address indexed spender, uint256 value);
              /**
               * @dev Returns the 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 `to`.
               *
               * Returns a boolean value indicating whether the operation succeeded.
               *
               * Emits a {Transfer} event.
               */
              function transfer(address to, uint256 amount) external returns (bool);
              /**
               * @dev Returns the remaining number of tokens that `spender` will be
               * allowed to spend on behalf of `owner` through {transferFrom}. This is
               * zero by default.
               *
               * This value changes when {approve} or {transferFrom} are called.
               */
              function allowance(address owner, address spender) external view returns (uint256);
              /**
               * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
               *
               * Returns a boolean value indicating whether the operation succeeded.
               *
               * IMPORTANT: Beware that changing an allowance with this method brings the risk
               * that someone may use both the old and the new allowance by unfortunate
               * transaction ordering. One possible solution to mitigate this race
               * condition is to first reduce the spender's allowance to 0 and set the
               * desired value afterwards:
               * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
               *
               * Emits an {Approval} event.
               */
              function approve(address spender, uint256 amount) external returns (bool);
              /**
               * @dev Moves `amount` tokens from `from` to `to` 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 from, address to, uint256 amount) external returns (bool);
          }// SPDX-License-Identifier: GPL-3.0-or-later
          pragma solidity >=0.8.0;
          import "openzeppelin/access/Ownable2Step.sol";
          abstract contract Auth is Ownable2Step {
              event SetTrusted(address indexed user, bool isTrusted);
              mapping(address => bool) public trusted;
              error OnlyTrusted();
              modifier onlyTrusted() {
                  if (!trusted[msg.sender]) revert OnlyTrusted();
                  _;
              }
              constructor(address trustedUser) {
                  trusted[trustedUser] = true;
                  emit SetTrusted(trustedUser, true);
              }
              function setTrusted(address user, bool isTrusted) external onlyOwner {
                  trusted[user] = isTrusted;
                  emit SetTrusted(user, isTrusted);
              }
          }// SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts (last updated v4.8.0) (access/Ownable2Step.sol)
          pragma solidity ^0.8.0;
          import "./Ownable.sol";
          /**
           * @dev Contract module which provides access control mechanism, where
           * there is an account (an owner) that can be granted exclusive access to
           * specific functions.
           *
           * By default, the owner account will be the one that deploys the contract. This
           * can later be changed with {transferOwnership} and {acceptOwnership}.
           *
           * This module is used through inheritance. It will make available all functions
           * from parent (Ownable).
           */
          abstract contract Ownable2Step is Ownable {
              address private _pendingOwner;
              event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
              /**
               * @dev Returns the address of the pending owner.
               */
              function pendingOwner() public view virtual returns (address) {
                  return _pendingOwner;
              }
              /**
               * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
               * Can only be called by the current owner.
               */
              function transferOwnership(address newOwner) public virtual override onlyOwner {
                  _pendingOwner = newOwner;
                  emit OwnershipTransferStarted(owner(), newOwner);
              }
              /**
               * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
               * Internal function without access restriction.
               */
              function _transferOwnership(address newOwner) internal virtual override {
                  delete _pendingOwner;
                  super._transferOwnership(newOwner);
              }
              /**
               * @dev The new owner accepts the ownership transfer.
               */
              function acceptOwnership() external {
                  address sender = _msgSender();
                  require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
                  _transferOwnership(sender);
              }
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
          pragma solidity ^0.8.0;
          import "../utils/Context.sol";
          /**
           * @dev Contract module which provides a basic access control mechanism, where
           * there is an account (an owner) that can be granted exclusive access to
           * specific functions.
           *
           * By default, the owner account will be the one that deploys the contract. This
           * can later be changed with {transferOwnership}.
           *
           * This module is used through inheritance. It will make available the modifier
           * `onlyOwner`, which can be applied to your functions to restrict their use to
           * the owner.
           */
          abstract contract Ownable is Context {
              address private _owner;
              event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
              /**
               * @dev Initializes the contract setting the deployer as the initial owner.
               */
              constructor() {
                  _transferOwnership(_msgSender());
              }
              /**
               * @dev Throws if called by any account other than the owner.
               */
              modifier onlyOwner() {
                  _checkOwner();
                  _;
              }
              /**
               * @dev Returns the address of the current owner.
               */
              function owner() public view virtual returns (address) {
                  return _owner;
              }
              /**
               * @dev Throws if the sender is not the owner.
               */
              function _checkOwner() internal view virtual {
                  require(owner() == _msgSender(), "Ownable: caller is not the owner");
              }
              /**
               * @dev Leaves the contract without owner. It will not be possible to call
               * `onlyOwner` functions anymore. Can only be called by the current owner.
               *
               * NOTE: Renouncing ownership will leave the contract without an owner,
               * thereby removing any functionality that is only available to the owner.
               */
              function renounceOwnership() public virtual onlyOwner {
                  _transferOwnership(address(0));
              }
              /**
               * @dev Transfers ownership of the contract to a new account (`newOwner`).
               * Can only be called by the current owner.
               */
              function transferOwnership(address newOwner) public virtual onlyOwner {
                  require(newOwner != address(0), "Ownable: new owner is the zero address");
                  _transferOwnership(newOwner);
              }
              /**
               * @dev Transfers ownership of the contract to a new account (`newOwner`).
               * Internal function without access restriction.
               */
              function _transferOwnership(address newOwner) internal virtual {
                  address oldOwner = _owner;
                  _owner = newOwner;
                  emit OwnershipTransferred(oldOwner, newOwner);
              }
          }
          // SPDX-License-Identifier: MIT
          // OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
          pragma solidity ^0.8.0;
          /**
           * @dev Provides information about the current execution context, including the
           * sender of the transaction and its data. While these are generally available
           * via msg.sender and msg.data, they should not be accessed in such a direct
           * manner, since when dealing with meta-transactions the account sending and
           * paying for execution may not be the actual sender (as far as an application
           * is concerned).
           *
           * This contract is only required for intermediate, library-like contracts.
           */
          abstract contract Context {
              function _msgSender() internal view virtual returns (address) {
                  return msg.sender;
              }
              function _msgData() internal view virtual returns (bytes calldata) {
                  return msg.data;
              }
          }