Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity 0.8.29;

import {WarpToadCore} from "./WarpToadCore.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract L2WarpToad is WarpToadCore {
    //@joss do what ever to the structure or naming or things if u feel like it
    constructor(
        uint8 _maxTreeDepth,
        address _withdrawVerifier,
        address _nativeToken,
        string memory name,
        string memory symbol
    ) ERC20(name, symbol) WarpToadCore(_maxTreeDepth, _withdrawVerifier, _nativeToken) {}

    function bridgeRoot() public view {
        localRoot(); // <- returns the localRoot!
        //TODO interact with the gigaBridge
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/draft-IERC6093.sol)
pragma solidity >=0.8.4;

/**
 * @dev Standard ERC-20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC-721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC-1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.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}.
 *
 * 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].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * 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 ERC-20
 * applications.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * Both 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 returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual 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 default value returned by this function, unless
     * it's 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 returns (uint8) {
        return 18;
    }

    /// @inheritdoc IERC20
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /// @inheritdoc IERC20
    function balanceOf(address account) public view virtual 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 `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /// @inheritdoc IERC20
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` 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 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Skips emitting an {Approval} event indicating an allowance update. This is not
     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
     *
     * 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 `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` 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.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` 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.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     *
     * ```solidity
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner`'s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance < type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity >=0.6.2;

import {IERC20} from "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC-20 standard.
 */
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 v5.4.0) (token/ERC20/IERC20.sol)

pragma solidity >=0.4.16;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

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

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

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

uint256 constant SNARK_SCALAR_FIELD = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
uint8 constant MAX_DEPTH = 32;

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

import {PoseidonT3} from "poseidon-solidity/PoseidonT3.sol";
import {SNARK_SCALAR_FIELD, MAX_DEPTH} from "./Constants.sol";

struct LazyIMTData {
    uint40 maxIndex;
    uint40 numberOfLeaves;
    mapping(uint256 => uint256) elements;
}

library InternalLazyIMT {
    uint40 internal constant MAX_INDEX = (1 << 32) - 1;

    uint256 internal constant Z_0 = 0;
    uint256 internal constant Z_1 = 14744269619966411208579211824598458697587494354926760081771325075741142829156;
    uint256 internal constant Z_2 = 7423237065226347324353380772367382631490014989348495481811164164159255474657;
    uint256 internal constant Z_3 = 11286972368698509976183087595462810875513684078608517520839298933882497716792;
    uint256 internal constant Z_4 = 3607627140608796879659380071776844901612302623152076817094415224584923813162;
    uint256 internal constant Z_5 = 19712377064642672829441595136074946683621277828620209496774504837737984048981;
    uint256 internal constant Z_6 = 20775607673010627194014556968476266066927294572720319469184847051418138353016;
    uint256 internal constant Z_7 = 3396914609616007258851405644437304192397291162432396347162513310381425243293;
    uint256 internal constant Z_8 = 21551820661461729022865262380882070649935529853313286572328683688269863701601;
    uint256 internal constant Z_9 = 6573136701248752079028194407151022595060682063033565181951145966236778420039;
    uint256 internal constant Z_10 = 12413880268183407374852357075976609371175688755676981206018884971008854919922;
    uint256 internal constant Z_11 = 14271763308400718165336499097156975241954733520325982997864342600795471836726;
    uint256 internal constant Z_12 = 20066985985293572387227381049700832219069292839614107140851619262827735677018;
    uint256 internal constant Z_13 = 9394776414966240069580838672673694685292165040808226440647796406499139370960;
    uint256 internal constant Z_14 = 11331146992410411304059858900317123658895005918277453009197229807340014528524;
    uint256 internal constant Z_15 = 15819538789928229930262697811477882737253464456578333862691129291651619515538;
    uint256 internal constant Z_16 = 19217088683336594659449020493828377907203207941212636669271704950158751593251;
    uint256 internal constant Z_17 = 21035245323335827719745544373081896983162834604456827698288649288827293579666;
    uint256 internal constant Z_18 = 6939770416153240137322503476966641397417391950902474480970945462551409848591;
    uint256 internal constant Z_19 = 10941962436777715901943463195175331263348098796018438960955633645115732864202;
    uint256 internal constant Z_20 = 15019797232609675441998260052101280400536945603062888308240081994073687793470;
    uint256 internal constant Z_21 = 11702828337982203149177882813338547876343922920234831094975924378932809409969;
    uint256 internal constant Z_22 = 11217067736778784455593535811108456786943573747466706329920902520905755780395;
    uint256 internal constant Z_23 = 16072238744996205792852194127671441602062027943016727953216607508365787157389;
    uint256 internal constant Z_24 = 17681057402012993898104192736393849603097507831571622013521167331642182653248;
    uint256 internal constant Z_25 = 21694045479371014653083846597424257852691458318143380497809004364947786214945;
    uint256 internal constant Z_26 = 8163447297445169709687354538480474434591144168767135863541048304198280615192;
    uint256 internal constant Z_27 = 14081762237856300239452543304351251708585712948734528663957353575674639038357;
    uint256 internal constant Z_28 = 16619959921569409661790279042024627172199214148318086837362003702249041851090;
    uint256 internal constant Z_29 = 7022159125197495734384997711896547675021391130223237843255817587255104160365;
    uint256 internal constant Z_30 = 4114686047564160449611603615418567457008101555090703535405891656262658644463;
    uint256 internal constant Z_31 = 12549363297364877722388257367377629555213421373705596078299904496781819142130;
    uint256 internal constant Z_32 = 21443572485391568159800782191812935835534334817699172242223315142338162256601;

    function _defaultZero(uint8 index) internal pure returns (uint256) {
        if (index == 0) return Z_0;
        if (index == 1) return Z_1;
        if (index == 2) return Z_2;
        if (index == 3) return Z_3;
        if (index == 4) return Z_4;
        if (index == 5) return Z_5;
        if (index == 6) return Z_6;
        if (index == 7) return Z_7;
        if (index == 8) return Z_8;
        if (index == 9) return Z_9;
        if (index == 10) return Z_10;
        if (index == 11) return Z_11;
        if (index == 12) return Z_12;
        if (index == 13) return Z_13;
        if (index == 14) return Z_14;
        if (index == 15) return Z_15;
        if (index == 16) return Z_16;
        if (index == 17) return Z_17;
        if (index == 18) return Z_18;
        if (index == 19) return Z_19;
        if (index == 20) return Z_20;
        if (index == 21) return Z_21;
        if (index == 22) return Z_22;
        if (index == 23) return Z_23;
        if (index == 24) return Z_24;
        if (index == 25) return Z_25;
        if (index == 26) return Z_26;
        if (index == 27) return Z_27;
        if (index == 28) return Z_28;
        if (index == 29) return Z_29;
        if (index == 30) return Z_30;
        if (index == 31) return Z_31;
        if (index == 32) return Z_32;
        revert("LazyIMT: defaultZero bad index");
    }

    function _init(LazyIMTData storage self, uint8 depth) internal {
        require(depth <= MAX_DEPTH, "LazyIMT: Tree too large");
        self.maxIndex = uint40((1 << depth) - 1);
        self.numberOfLeaves = 0;
    }

    function _reset(LazyIMTData storage self) internal {
        self.numberOfLeaves = 0;
    }

    function _indexForElement(uint8 level, uint40 index) internal pure returns (uint40) {
        // store the elements sparsely
        return MAX_INDEX * level + index;
    }

    function _insert(LazyIMTData storage self, uint256 leaf) internal {
        uint40 index = self.numberOfLeaves;
        require(leaf < SNARK_SCALAR_FIELD, "LazyIMT: leaf must be < SNARK_SCALAR_FIELD");
        require(index < self.maxIndex, "LazyIMT: tree is full");

        self.numberOfLeaves = index + 1;

        uint256 hash = leaf;

        for (uint8 i = 0; ; ) {
            self.elements[_indexForElement(i, index)] = hash;
            // it's a left element so we don't hash until there's a right element
            if (index & 1 == 0) break;
            uint40 elementIndex = _indexForElement(i, index - 1);
            hash = PoseidonT3.hash([self.elements[elementIndex], hash]);
            unchecked {
                index >>= 1;
                i++;
            }
        }
    }

    function _update(LazyIMTData storage self, uint256 leaf, uint40 index) internal {
        require(leaf < SNARK_SCALAR_FIELD, "LazyIMT: leaf must be < SNARK_SCALAR_FIELD");
        uint40 numberOfLeaves = self.numberOfLeaves;
        require(index < numberOfLeaves, "LazyIMT: leaf must exist");

        uint256 hash = leaf;

        for (uint8 i = 0; true; ) {
            self.elements[_indexForElement(i, index)] = hash;
            uint256 levelCount = numberOfLeaves >> (i + 1);
            if (levelCount <= index >> 1) break;
            if (index & 1 == 0) {
                uint40 elementIndex = _indexForElement(i, index + 1);
                hash = PoseidonT3.hash([hash, self.elements[elementIndex]]);
            } else {
                uint40 elementIndex = _indexForElement(i, index - 1);
                hash = PoseidonT3.hash([self.elements[elementIndex], hash]);
            }
            unchecked {
                index >>= 1;
                i++;
            }
        }
    }

    function _root(LazyIMTData storage self) internal view returns (uint256) {
        // this will always short circuit if self.numberOfLeaves == 0
        uint40 numberOfLeaves = self.numberOfLeaves;
        // dynamically determine a depth
        uint8 depth = 1;
        while (uint40(2) ** uint40(depth) < numberOfLeaves) {
            depth++;
        }
        return _root(self, numberOfLeaves, depth);
    }

    function _root(LazyIMTData storage self, uint8 depth) internal view returns (uint256) {
        require(depth > 0, "LazyIMT: depth must be > 0");
        require(depth <= MAX_DEPTH, "LazyIMT: depth must be <= MAX_DEPTH");
        uint40 numberOfLeaves = self.numberOfLeaves;
        require(uint40(2) ** uint40(depth) >= numberOfLeaves, "LazyIMT: ambiguous depth");
        return _root(self, numberOfLeaves, depth);
    }

    // Here it's assumed that the depth value is valid. If it is either 0 or > 2^8-1
    // this function will panic.
    function _root(LazyIMTData storage self, uint40 numberOfLeaves, uint8 depth) internal view returns (uint256) {
        require(depth <= MAX_DEPTH, "LazyIMT: depth must be <= MAX_DEPTH");
        // this should always short circuit if self.numberOfLeaves == 0
        if (numberOfLeaves == 0) return _defaultZero(depth);
        uint256[] memory levels = new uint256[](depth + 1);
        _levels(self, numberOfLeaves, depth, levels);
        return levels[depth];
    }

    function _levels(
        LazyIMTData storage self,
        uint40 numberOfLeaves,
        uint8 depth,
        uint256[] memory levels
    ) internal view {
        require(depth <= MAX_DEPTH, "LazyIMT: depth must be <= MAX_DEPTH");
        require(numberOfLeaves > 0, "LazyIMT: number of leaves must be > 0");
        // this should always short circuit if self.numberOfLeaves == 0
        uint40 index = numberOfLeaves - 1;

        if (index & 1 == 0) {
            levels[0] = self.elements[_indexForElement(0, index)];
        } else {
            levels[0] = _defaultZero(0);
        }

        for (uint8 i = 0; i < depth; ) {
            if (index & 1 == 0) {
                levels[i + 1] = PoseidonT3.hash([levels[i], _defaultZero(i)]);
            } else {
                uint256 levelCount = (numberOfLeaves) >> (i + 1);
                if (levelCount > index >> 1) {
                    uint256 parent = self.elements[_indexForElement(i + 1, index >> 1)];
                    levels[i + 1] = parent;
                } else {
                    uint256 sibling = self.elements[_indexForElement(i, index - 1)];
                    levels[i + 1] = PoseidonT3.hash([sibling, levels[i]]);
                }
            }
            unchecked {
                index >>= 1;
                i++;
            }
        }
    }

    function _merkleProofElements(
        LazyIMTData storage self,
        uint40 index,
        uint8 depth
    ) internal view returns (uint256[] memory) {
        uint40 numberOfLeaves = self.numberOfLeaves;
        require(index < numberOfLeaves, "LazyIMT: leaf must exist");

        uint8 targetDepth = 1;
        while (uint40(2) ** uint40(targetDepth) < numberOfLeaves) {
            targetDepth++;
        }
        require(depth >= targetDepth, "LazyIMT: proof depth");
        // pass depth -1 because we don't need the root value
        uint256[] memory _elements = new uint256[](depth);
        _levels(self, numberOfLeaves, targetDepth - 1, _elements);

        // unroll the bottom entry of the tree because it will never need to
        // be pulled from _levels
        if (index & 1 == 0) {
            if (index + 1 >= numberOfLeaves) {
                _elements[0] = _defaultZero(0);
            } else {
                _elements[0] = self.elements[_indexForElement(0, index + 1)];
            }
        } else {
            _elements[0] = self.elements[_indexForElement(0, index - 1)];
        }
        index >>= 1;

        for (uint8 i = 1; i < depth; ) {
            uint256 currentLevelCount = numberOfLeaves >> i;
            if (index & 1 == 0) {
                // if the element is an uncomputed edge node we'll use the value set
                // from _levels above
                // otherwise set as usual below
                if (index + 1 < currentLevelCount) {
                    _elements[i] = self.elements[_indexForElement(i, index + 1)];
                } else if (((numberOfLeaves - 1) >> i) <= index) {
                    _elements[i] = _defaultZero(i);
                }
            } else {
                _elements[i] = self.elements[_indexForElement(i, index - 1)];
            }
            unchecked {
                index >>= 1;
                i++;
            }
        }
        return _elements;
    }
}

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

import {InternalLazyIMT, LazyIMTData} from "./InternalLazyIMT.sol";

library LazyIMT {
    using InternalLazyIMT for *;

    function init(LazyIMTData storage self, uint8 depth) public {
        InternalLazyIMT._init(self, depth);
    }

    function defaultZero(uint8 index) public pure returns (uint256) {
        return InternalLazyIMT._defaultZero(index);
    }

    function reset(LazyIMTData storage self) public {
        InternalLazyIMT._reset(self);
    }

    function indexForElement(uint8 level, uint40 index) public pure returns (uint40) {
        return InternalLazyIMT._indexForElement(level, index);
    }

    function insert(LazyIMTData storage self, uint256 leaf) public {
        InternalLazyIMT._insert(self, leaf);
    }

    function update(LazyIMTData storage self, uint256 leaf, uint40 index) public {
        InternalLazyIMT._update(self, leaf, index);
    }

    function root(LazyIMTData storage self) public view returns (uint256) {
        return InternalLazyIMT._root(self);
    }

    function root(LazyIMTData storage self, uint8 depth) public view returns (uint256) {
        return InternalLazyIMT._root(self, depth);
    }

    function merkleProofElements(
        LazyIMTData storage self,
        uint40 index,
        uint8 depth
    ) public view returns (uint256[] memory) {
        return InternalLazyIMT._merkleProofElements(self, index, depth);
    }

    function _root(LazyIMTData storage self, uint40 numberOfLeaves, uint8 depth) internal view returns (uint256) {
        return InternalLazyIMT._root(self, numberOfLeaves, depth);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.29;

interface IGigaRootProvider {
    function sendGigaRoot(address _gigaRootRecipient) external payable;
    function gigaRoot() external returns(uint256);
}

interface IGigaRootRecipient {
    function receiveGigaRoot(uint256 _gigaRoot) payable external;
    //function receiveGigaRoot(uint256 _gigaRoot, uint256 _gasLimit) payable external;
}


interface ILocalRootProvider {
    function getLocalRootAndBlock() external returns (uint256, uint256);
}

interface ILocalRootRecipient {
    //only gigaBridge does this
    //function updateGigaRoot(address[] memory _localRootProvider) external;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.29;


interface IWarpToadCore {
    event Burn(uint256 indexed commitment, uint256 amount, uint256 index);
    function initialize(address _gigaRootProvider, address _l1BridgeAdapter, uint256 _aztecWarptoadAddress) external;
    function isValidGigaRoot(uint256 _gigaRoot) external view returns (bool);
    function burn(uint256 _preCommitment, uint256 _amount) external;

    // our tree is lazy so we 
    function storeLocalRootInHistory() external returns(uint256);

    function _formatPublicInputs(        
        uint256 _nullifier,
        uint256 _chainId,
        uint256 _amount,
        uint256 _gigaRoot,
        uint256 _localRoot,
        uint256 _aztecWarptoadAddress,
        uint256 _feeFactor,
        uint256 _priorityFee,
        uint256 _maxFee,
        address _relayer,
        address _recipient
    ) external pure returns (bytes32[] memory);


    // TODO relayer support
    function mint(
        uint256 _nullifier,
        uint256 _amount,
        uint256 _gigaRoot,
        uint256 _localRoot,
        uint256 _feeFactor,
        uint256 _priorityFee,
        uint256 _maxFee,
        address _relayer,
        address _recipient,
        bytes memory _poof
    ) external;

    function localRoot() external view returns (uint256);
    function isValidLocalRoot(uint256 _localRoot) external view returns (bool);

    // gigaRootProvider can call directly since are on the L1 already and don't need adapter
    // IGigaRootRecipient and ILocalRootProvider
//     function receiveGigaRoot(uint256 _gigaRoot) external;
//     function getLocalRootAndBlock() external returns (uint256, uint256);
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.29;

import {PoseidonT3} from "poseidon-solidity/PoseidonT3.sol";
import {LazyIMT, LazyIMTData} from "@zk-kit/lazy-imt.sol/LazyIMT.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IWarpToadCore} from "../interfaces/IWarpToadCore.sol";
import {ILocalRootProvider, IGigaRootRecipient} from "../interfaces/IRootMessengers.sol";
import {IGigaRootProvider} from "../interfaces/IRootMessengers.sol";

// tutorial https://github.com/privacy-scaling-explorations/zk-kit.solidity/blob/main/packages/lean-imt/contracts/test/LazyIMTTest.sol
// noir equivalent (normal merkle tree): https://github.com/privacy-scaling-explorations/zk-kit.noir/tree/main/packages/merkle-trees
// ts/js: https://github.com/privacy-scaling-explorations/zk-kit/tree/main/packages/lean-imt

interface IVerifier {
    function verify(
        bytes calldata _proof,
        bytes32[] calldata _publicInputs
    ) external view returns (bool);
}

abstract contract WarpToadCore is ERC20, IWarpToadCore,ILocalRootProvider, IGigaRootRecipient {
    modifier onlyGigaRootProvider() {
        require(msg.sender == gigaRootProvider, "Not gigaRootProvider");
        _; // what is that?
    }

    modifier onlyDeployer() {
        require(msg.sender == deployer, "Not the deployer");
        _; // what is that?
    }
    
    address deployer;

    LazyIMTData public commitTreeData; // does this need to be public?
    uint8 public maxTreeDepth;

    uint256 public cachedLocalRoot;
    uint256 public gigaRoot;
    mapping(uint256 => bool) public gigaRootHistory; // TODO limit the history so we override slots is more efficient and is easier for clients to implement contract interactions
    mapping(uint256 => bool) public localRootHistory; 
    mapping(uint256 => bool) public nullifiers;

    address public l1BridgeAdapter;  // just here so we can look it up in frontend (l1BridgeAdapter is the address that maps to leaves(localRoots) in the gigaTree)
    address public gigaRootProvider; // only contract that is allowed to provide giga roots
    address public withdrawVerifier;
    uint256 public aztecWarptoadAddress; // since we use aztecs global note_hash_tree

    uint256 public lastLeafIndex;

    address public nativeToken;

    constructor(uint8 _maxTreeDepth, address _withdrawVerifier, address _nativeToken) {
        maxTreeDepth = _maxTreeDepth;
        // maxBurns = 2 ** _maxTreeDepth; // circuit cant go above this number

        withdrawVerifier = _withdrawVerifier;
        LazyIMT.init(commitTreeData, _maxTreeDepth);
        nativeToken = _nativeToken;
        deployer = msg.sender;
    }

    // needs initialize because the gigaBridge sets its localRootProvider (inc L1WarpToad) in the constructor
    // 
    function initialize(address _gigaRootProvider, address _l1BridgeAdapter, uint256 _aztecWarptoadAddress) public onlyDeployer() {
        require(gigaRootProvider == address(0), "gigaRootProvider is already set");
        require(l1BridgeAdapter == address(0), "l1BridgeAdapter is already set");
        require(aztecWarptoadAddress == uint256(0), "aztecWarptoadAddress is already set");
        gigaRootProvider = _gigaRootProvider;
        l1BridgeAdapter = _l1BridgeAdapter;
        aztecWarptoadAddress = _aztecWarptoadAddress;

        // so we dont end up with gigaRoot being = 0
        uint256 _gigaRoot = IGigaRootProvider(_gigaRootProvider).gigaRoot();
        gigaRootHistory[_gigaRoot] = true;
        gigaRoot = _gigaRoot;

        // other wise cachedLocalRoot can be 0. Which i cant see how that would be a issue but it scares so we do this to be safe
        storeLocalRootInHistory();
    }

    function decimals() public view virtual override returns (uint8) {
        return 6;
    }

    function isValidGigaRoot(uint256 _gigaRoot) public view returns (bool) {
        return gigaRootHistory[_gigaRoot];
    }

    function burn(uint256 _preCommitment, uint256 _amount) public {
        //require(totalBurns < maxBurns, "Tree wil exceed the maxTreeDepth");

        _burn(msg.sender, _amount);

        uint256 _commitment = PoseidonT3.hash([_preCommitment, _amount]);
        LazyIMT.insert(commitTreeData, _commitment);
        // This is inefficient, but not doing this creates devUx pain and even problematic privacyUX
        // the proper version of warptoad is going to use leanIMT anyway which has a similar gas footprint and always has a root!
        storeLocalRootInHistory();
        emit Burn(_commitment, _amount, lastLeafIndex);
        lastLeafIndex++;
    }

    // our tree is lazy so we 
    function storeLocalRootInHistory() public returns(uint256) {
        uint256 root = localRoot();
        cachedLocalRoot = root;
        localRootHistory[root] = true;
        return root;
    }

    function _formatPublicInputs(        
        uint256 _nullifier,
        uint256 _chainId,
        uint256 _amount,
        uint256 _gigaRoot,
        uint256 _localRoot,
        uint256 _aztecWarptoadAddress,
        uint256 _feeFactor,
        uint256 _priorityFee,
        uint256 _maxFee,
        address _relayer,
        address _recipient
    ) public pure returns (bytes32[] memory) {
        bytes32[] memory publicInputs = new bytes32[](11);
        // TODO is this expensive gas wise?
        uint256[9] memory uintInputs = [_nullifier,_chainId,_amount,_gigaRoot,_localRoot,_aztecWarptoadAddress,_feeFactor,_priorityFee,_maxFee];
        address[2] memory addressInputs = [_relayer, _recipient];
        
        for (uint256 i = 0; i < uintInputs.length; i++) {
            publicInputs[i] = bytes32(uintInputs[i]);
        }
        uint256 indexAfterUints = uintInputs.length; 
        for (uint256 i = 0; i < addressInputs.length; i++) {
            publicInputs[indexAfterUints + i] = bytes32(uint256(uint160(bytes20(addressInputs[i])))); // silly ah solidity way to get left padded 32bytes hopefully the compiler doesn't make it look silly
        }
        return publicInputs;
    }

    // TODO relayer support
    function mint(
        uint256 _nullifier,
        uint256 _amount,
        uint256 _gigaRoot,
        uint256 _localRoot,
        uint256 _feeFactor,
        uint256 _priorityFee,
        uint256 _maxFee,
        address _relayer,
        address _recipient,
        bytes memory _poof
    ) public {
        require(isValidGigaRoot(_gigaRoot), "_gigaRoot unknown");
        require(isValidLocalRoot(_localRoot), "_localRoot unknown"); 
        require(nullifiers[_nullifier] == false, "nullifier already exists");
        nullifiers[_nullifier] = true;
        
        bytes32[] memory _publicInputs = _formatPublicInputs(_nullifier, block.chainid, _amount, _gigaRoot, _localRoot, aztecWarptoadAddress, _feeFactor, _priorityFee, _maxFee, _relayer, _recipient);
        require(IVerifier(withdrawVerifier).verify(_poof, _publicInputs), "invalid proof"); 

        // fee logic       
        if (_feeFactor != 0 ) { // 
            uint256 _relayerFee = _feeFactor * (block.basefee + _priorityFee); // TODO double check precision. Prob only breaks if the wrpToad token price is super high or gas cost super low
            require(_relayerFee <= _maxFee, "_relayerFee is larger than _maxFee");
            // for compatibility with permissionless relaying
            if (_relayer == address(1)){
                _relayer = msg.sender;
            }
            _mint(_relayer, _relayerFee);
            _mint(_recipient, _amount - _relayerFee);
        } else {
            // its self relayed or relayer is just nice :D
            _mint(_recipient, _amount);
        }
    }

    function localRoot() public view returns (uint256) {
        return LazyIMT.root(commitTreeData, maxTreeDepth);
    }

    function isValidLocalRoot(uint256 _localRoot) public view returns (bool) {
        return localRootHistory[_localRoot];
    }

    // gigaRootProvider can call directly since are on the L1 already and dont need adapter
    function receiveGigaRoot(uint256 _gigaRoot) public payable onlyGigaRootProvider() {
        gigaRootHistory[_gigaRoot] = true;
        gigaRoot = _gigaRoot;
    }


    function getLocalRootAndBlock() external returns (uint256, uint256) {
        storeLocalRootInHistory();
        return (cachedLocalRoot, block.number);
    }

    function getFreeShit(uint256 _amount) public {
        _mint( msg.sender, _amount);
    }

    function nullifierExists(uint256 _nullifier) public view returns (bool) {
        return nullifiers[_nullifier];
    }
}

/// SPDX-License-Identifier: MIT
pragma solidity >=0.7.0;

library PoseidonT3 {
  uint constant M00 = 0x109b7f411ba0e4c9b2b70caf5c36a7b194be7c11ad24378bfedb68592ba8118b;
  uint constant M01 = 0x2969f27eed31a480b9c36c764379dbca2cc8fdd1415c3dded62940bcde0bd771;
  uint constant M02 = 0x143021ec686a3f330d5f9e654638065ce6cd79e28c5b3753326244ee65a1b1a7;
  uint constant M10 = 0x16ed41e13bb9c0c66ae119424fddbcbc9314dc9fdbdeea55d6c64543dc4903e0;
  uint constant M11 = 0x2e2419f9ec02ec394c9871c832963dc1b89d743c8c7b964029b2311687b1fe23;
  uint constant M12 = 0x176cc029695ad02582a70eff08a6fd99d057e12e58e7d7b6b16cdfabc8ee2911;

  // See here for a simplified implementation: https://github.com/vimwitch/poseidon-solidity/blob/e57becdabb65d99fdc586fe1e1e09e7108202d53/contracts/Poseidon.sol#L40
  // Inspired by: https://github.com/iden3/circomlibjs/blob/v0.0.8/src/poseidon_slow.js
  function hash(uint[2] memory) public pure returns (uint) {
    assembly {
      let F := 21888242871839275222246405745257275088548364400416034343698204186575808495617
      let M20 := 0x2b90bba00fca0589f617e7dcbfe82e0df706ab640ceb247b791a93b74e36736d
      let M21 := 0x101071f0032379b697315876690f053d148d4e109f5fb065c8aacc55a0f89bfa
      let M22 := 0x19a3fc0a56702bf417ba7fee3802593fa644470307043f7773279cd71d25d5e0

      // load the inputs from memory
      let state1 := add(mod(mload(0x80), F), 0x00f1445235f2148c5986587169fc1bcd887b08d4d00868df5696fff40956e864)
      let state2 := add(mod(mload(0xa0), F), 0x08dff3487e8ac99e1f29a058d0fa80b930c728730b7ab36ce879f3890ecf73f5)
      let scratch0 := mulmod(state1, state1, F)
      state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)
      scratch0 := mulmod(state2, state2, F)
      state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)
      scratch0 := add(
        0x2f27be690fdaee46c3ce28f7532b13c856c35342c84bda6e20966310fadc01d0,
        add(add(15452833169820924772166449970675545095234312153403844297388521437673434406763, mulmod(state1, M10, F)), mulmod(state2, M20, F))
      )
      let scratch1 := add(
        0x2b2ae1acf68b7b8d2416bebf3d4f6234b763fe04b8043ee48b8327bebca16cf2,
        add(add(18674271267752038776579386132900109523609358935013267566297499497165104279117, mulmod(state1, M11, F)), mulmod(state2, M21, F))
      )
      let scratch2 := add(
        0x0319d062072bef7ecca5eac06f97d4d55952c175ab6b03eae64b44c7dbf11cfa,
        add(add(14817777843080276494683266178512808687156649753153012854386334860566696099579, mulmod(state1, M12, F)), mulmod(state2, M22, F))
      )
      let state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := mulmod(scratch1, scratch1, F)
      scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)
      state0 := mulmod(scratch2, scratch2, F)
      scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)
      state0 := add(0x28813dcaebaeaa828a376df87af4a63bc8b7bf27ad49c6298ef7b387bf28526d, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x2727673b2ccbc903f181bf38e1c1d40d2033865200c352bc150928adddf9cb78, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x234ec45ca27727c2e74abd2b2a1494cd6efbd43e340587d6b8fb9e31e65cc632, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := mulmod(state1, state1, F)
      state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)
      scratch0 := mulmod(state2, state2, F)
      state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)
      scratch0 := add(0x15b52534031ae18f7f862cb2cf7cf760ab10a8150a337b1ccd99ff6e8797d428, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x0dc8fad6d9e4b35f5ed9a3d186b79ce38e0e8a8d1b58b132d701d4eecf68d1f6, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x1bcd95ffc211fbca600f705fad3fb567ea4eb378f62e1fec97805518a47e4d9c, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := mulmod(scratch1, scratch1, F)
      scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)
      state0 := mulmod(scratch2, scratch2, F)
      scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)
      state0 := add(0x10520b0ab721cadfe9eff81b016fc34dc76da36c2578937817cb978d069de559, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x1f6d48149b8e7f7d9b257d8ed5fbbaf42932498075fed0ace88a9eb81f5627f6, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x1d9655f652309014d29e00ef35a2089bfff8dc1c816f0dc9ca34bdb5460c8705, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x04df5a56ff95bcafb051f7b1cd43a99ba731ff67e47032058fe3d4185697cc7d, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x0672d995f8fff640151b3d290cedaf148690a10a8c8424a7f6ec282b6e4be828, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x099952b414884454b21200d7ffafdd5f0c9a9dcc06f2708e9fc1d8209b5c75b9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x052cba2255dfd00c7c483143ba8d469448e43586a9b4cd9183fd0e843a6b9fa6, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x0b8badee690adb8eb0bd74712b7999af82de55707251ad7716077cb93c464ddc, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x119b1590f13307af5a1ee651020c07c749c15d60683a8050b963d0a8e4b2bdd1, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x03150b7cd6d5d17b2529d36be0f67b832c4acfc884ef4ee5ce15be0bfb4a8d09, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x2cc6182c5e14546e3cf1951f173912355374efb83d80898abe69cb317c9ea565, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x005032551e6378c450cfe129a404b3764218cadedac14e2b92d2cd73111bf0f9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x233237e3289baa34bb147e972ebcb9516469c399fcc069fb88f9da2cc28276b5, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x05c8f4f4ebd4a6e3c980d31674bfbe6323037f21b34ae5a4e80c2d4c24d60280, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x0a7b1db13042d396ba05d818a319f25252bcf35ef3aeed91ee1f09b2590fc65b, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x2a73b71f9b210cf5b14296572c9d32dbf156e2b086ff47dc5df542365a404ec0, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x1ac9b0417abcc9a1935107e9ffc91dc3ec18f2c4dbe7f22976a760bb5c50c460, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x12c0339ae08374823fabb076707ef479269f3e4d6cb104349015ee046dc93fc0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x0b7475b102a165ad7f5b18db4e1e704f52900aa3253baac68246682e56e9a28e, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x037c2849e191ca3edb1c5e49f6e8b8917c843e379366f2ea32ab3aa88d7f8448, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x05a6811f8556f014e92674661e217e9bd5206c5c93a07dc145fdb176a716346f, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x29a795e7d98028946e947b75d54e9f044076e87a7b2883b47b675ef5f38bd66e, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x20439a0c84b322eb45a3857afc18f5826e8c7382c8a1585c507be199981fd22f, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x2e0ba8d94d9ecf4a94ec2050c7371ff1bb50f27799a84b6d4a2a6f2a0982c887, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x143fd115ce08fb27ca38eb7cce822b4517822cd2109048d2e6d0ddcca17d71c8, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x0c64cbecb1c734b857968dbbdcf813cdf8611659323dbcbfc84323623be9caf1, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x028a305847c683f646fca925c163ff5ae74f348d62c2b670f1426cef9403da53, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x2e4ef510ff0b6fda5fa940ab4c4380f26a6bcb64d89427b824d6755b5db9e30c, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x0081c95bc43384e663d79270c956ce3b8925b4f6d033b078b96384f50579400e, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x2ed5f0c91cbd9749187e2fade687e05ee2491b349c039a0bba8a9f4023a0bb38, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x30509991f88da3504bbf374ed5aae2f03448a22c76234c8c990f01f33a735206, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x1c3f20fd55409a53221b7c4d49a356b9f0a1119fb2067b41a7529094424ec6ad, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x10b4e7f3ab5df003049514459b6e18eec46bb2213e8e131e170887b47ddcb96c, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x2a1982979c3ff7f43ddd543d891c2abddd80f804c077d775039aa3502e43adef, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x1c74ee64f15e1db6feddbead56d6d55dba431ebc396c9af95cad0f1315bd5c91, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x07533ec850ba7f98eab9303cace01b4b9e4f2e8b82708cfa9c2fe45a0ae146a0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x21576b438e500449a151e4eeaf17b154285c68f42d42c1808a11abf3764c0750, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x2f17c0559b8fe79608ad5ca193d62f10bce8384c815f0906743d6930836d4a9e, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x2d477e3862d07708a79e8aae946170bc9775a4201318474ae665b0b1b7e2730e, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x162f5243967064c390e095577984f291afba2266c38f5abcd89be0f5b2747eab, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x2b4cb233ede9ba48264ecd2c8ae50d1ad7a8596a87f29f8a7777a70092393311, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x2c8fbcb2dd8573dc1dbaf8f4622854776db2eece6d85c4cf4254e7c35e03b07a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x1d6f347725e4816af2ff453f0cd56b199e1b61e9f601e9ade5e88db870949da9, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x204b0c397f4ebe71ebc2d8b3df5b913df9e6ac02b68d31324cd49af5c4565529, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x0c4cb9dc3c4fd8174f1149b3c63c3c2f9ecb827cd7dc25534ff8fb75bc79c502, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x174ad61a1448c899a25416474f4930301e5c49475279e0639a616ddc45bc7b54, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x1a96177bcf4d8d89f759df4ec2f3cde2eaaa28c177cc0fa13a9816d49a38d2ef, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x066d04b24331d71cd0ef8054bc60c4ff05202c126a233c1a8242ace360b8a30a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x2a4c4fc6ec0b0cf52195782871c6dd3b381cc65f72e02ad527037a62aa1bd804, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x13ab2d136ccf37d447e9f2e14a7cedc95e727f8446f6d9d7e55afc01219fd649, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x1121552fca26061619d24d843dc82769c1b04fcec26f55194c2e3e869acc6a9a, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x00ef653322b13d6c889bc81715c37d77a6cd267d595c4a8909a5546c7c97cff1, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x0e25483e45a665208b261d8ba74051e6400c776d652595d9845aca35d8a397d3, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x29f536dcb9dd7682245264659e15d88e395ac3d4dde92d8c46448db979eeba89, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x2a56ef9f2c53febadfda33575dbdbd885a124e2780bbea170e456baace0fa5be, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x1c8361c78eb5cf5decfb7a2d17b5c409f2ae2999a46762e8ee416240a8cb9af1, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x151aff5f38b20a0fc0473089aaf0206b83e8e68a764507bfd3d0ab4be74319c5, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x04c6187e41ed881dc1b239c88f7f9d43a9f52fc8c8b6cdd1e76e47615b51f100, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x13b37bd80f4d27fb10d84331f6fb6d534b81c61ed15776449e801b7ddc9c2967, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x01a5c536273c2d9df578bfbd32c17b7a2ce3664c2a52032c9321ceb1c4e8a8e4, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x2ab3561834ca73835ad05f5d7acb950b4a9a2c666b9726da832239065b7c3b02, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x1d4d8ec291e720db200fe6d686c0d613acaf6af4e95d3bf69f7ed516a597b646, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x041294d2cc484d228f5784fe7919fd2bb925351240a04b711514c9c80b65af1d, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x154ac98e01708c611c4fa715991f004898f57939d126e392042971dd90e81fc6, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x0b339d8acca7d4f83eedd84093aef51050b3684c88f8b0b04524563bc6ea4da4, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x0955e49e6610c94254a4f84cfbab344598f0e71eaff4a7dd81ed95b50839c82e, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x06746a6156eba54426b9e22206f15abca9a6f41e6f535c6f3525401ea0654626, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x0f18f5a0ecd1423c496f3820c549c27838e5790e2bd0a196ac917c7ff32077fb, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x04f6eeca1751f7308ac59eff5beb261e4bb563583ede7bc92a738223d6f76e13, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x2b56973364c4c4f5c1a3ec4da3cdce038811eb116fb3e45bc1768d26fc0b3758, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x123769dd49d5b054dcd76b89804b1bcb8e1392b385716a5d83feb65d437f29ef, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x2147b424fc48c80a88ee52b91169aacea989f6446471150994257b2fb01c63e9, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x0fdc1f58548b85701a6c5505ea332a29647e6f34ad4243c2ea54ad897cebe54d, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x12373a8251fea004df68abcf0f7786d4bceff28c5dbbe0c3944f685cc0a0b1f2, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x21e4f4ea5f35f85bad7ea52ff742c9e8a642756b6af44203dd8a1f35c1a90035, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x16243916d69d2ca3dfb4722224d4c462b57366492f45e90d8a81934f1bc3b147, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x1efbe46dd7a578b4f66f9adbc88b4378abc21566e1a0453ca13a4159cac04ac2, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x07ea5e8537cf5dd08886020e23a7f387d468d5525be66f853b672cc96a88969a, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x05a8c4f9968b8aa3b7b478a30f9a5b63650f19a75e7ce11ca9fe16c0b76c00bc, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x20f057712cc21654fbfe59bd345e8dac3f7818c701b9c7882d9d57b72a32e83f, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x04a12ededa9dfd689672f8c67fee31636dcd8e88d01d49019bd90b33eb33db69, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x27e88d8c15f37dcee44f1e5425a51decbd136ce5091a6767e49ec9544ccd101a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x2feed17b84285ed9b8a5c8c5e95a41f66e096619a7703223176c41ee433de4d1, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x1ed7cc76edf45c7c404241420f729cf394e5942911312a0d6972b8bd53aff2b8, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x15742e99b9bfa323157ff8c586f5660eac6783476144cdcadf2874be45466b1a, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x1aac285387f65e82c895fc6887ddf40577107454c6ec0317284f033f27d0c785, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x25851c3c845d4790f9ddadbdb6057357832e2e7a49775f71ec75a96554d67c77, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x15a5821565cc2ec2ce78457db197edf353b7ebba2c5523370ddccc3d9f146a67, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x2411d57a4813b9980efa7e31a1db5966dcf64f36044277502f15485f28c71727, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x002e6f8d6520cd4713e335b8c0b6d2e647e9a98e12f4cd2558828b5ef6cb4c9b, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x2ff7bc8f4380cde997da00b616b0fcd1af8f0e91e2fe1ed7398834609e0315d2, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x00b9831b948525595ee02724471bcd182e9521f6b7bb68f1e93be4febb0d3cbe, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x0a2f53768b8ebf6a86913b0e57c04e011ca408648a4743a87d77adbf0c9c3512, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x00248156142fd0373a479f91ff239e960f599ff7e94be69b7f2a290305e1198d, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x171d5620b87bfb1328cf8c02ab3f0c9a397196aa6a542c2350eb512a2b2bcda9, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x170a4f55536f7dc970087c7c10d6fad760c952172dd54dd99d1045e4ec34a808, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x29aba33f799fe66c2ef3134aea04336ecc37e38c1cd211ba482eca17e2dbfae1, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x1e9bc179a4fdd758fdd1bb1945088d47e70d114a03f6a0e8b5ba650369e64973, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x1dd269799b660fad58f7f4892dfb0b5afeaad869a9c4b44f9c9e1c43bdaf8f09, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x22cdbc8b70117ad1401181d02e15459e7ccd426fe869c7c95d1dd2cb0f24af38, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x0ef042e454771c533a9f57a55c503fcefd3150f52ed94a7cd5ba93b9c7dacefd, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x11609e06ad6c8fe2f287f3036037e8851318e8b08a0359a03b304ffca62e8284, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x1166d9e554616dba9e753eea427c17b7fecd58c076dfe42708b08f5b783aa9af, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x2de52989431a859593413026354413db177fbf4cd2ac0b56f855a888357ee466, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x3006eb4ffc7a85819a6da492f3a8ac1df51aee5b17b8e89d74bf01cf5f71e9ad, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x2af41fbb61ba8a80fdcf6fff9e3f6f422993fe8f0a4639f962344c8225145086, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x119e684de476155fe5a6b41a8ebc85db8718ab27889e85e781b214bace4827c3, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x1835b786e2e8925e188bea59ae363537b51248c23828f047cff784b97b3fd800, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x28201a34c594dfa34d794996c6433a20d152bac2a7905c926c40e285ab32eeb6, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x083efd7a27d1751094e80fefaf78b000864c82eb571187724a761f88c22cc4e7, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x0b6f88a3577199526158e61ceea27be811c16df7774dd8519e079564f61fd13b, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x0ec868e6d15e51d9644f66e1d6471a94589511ca00d29e1014390e6ee4254f5b, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x2af33e3f866771271ac0c9b3ed2e1142ecd3e74b939cd40d00d937ab84c98591, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x0b520211f904b5e7d09b5d961c6ace7734568c547dd6858b364ce5e47951f178, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x0b2d722d0919a1aad8db58f10062a92ea0c56ac4270e822cca228620188a1d40, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x1f790d4d7f8cf094d980ceb37c2453e957b54a9991ca38bbe0061d1ed6e562d4, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x0171eb95dfbf7d1eaea97cd385f780150885c16235a2a6a8da92ceb01e504233, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x0c2d0e3b5fd57549329bf6885da66b9b790b40defd2c8650762305381b168873, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x1162fb28689c27154e5a8228b4e72b377cbcafa589e283c35d3803054407a18d, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x2f1459b65dee441b64ad386a91e8310f282c5a92a89e19921623ef8249711bc0, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x1e6ff3216b688c3d996d74367d5cd4c1bc489d46754eb712c243f70d1b53cfbb, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x01ca8be73832b8d0681487d27d157802d741a6f36cdc2a0576881f9326478875, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x1f7735706ffe9fc586f976d5bdf223dc680286080b10cea00b9b5de315f9650e, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x2522b60f4ea3307640a0c2dce041fba921ac10a3d5f096ef4745ca838285f019, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x23f0bee001b1029d5255075ddc957f833418cad4f52b6c3f8ce16c235572575b, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x2bc1ae8b8ddbb81fcaac2d44555ed5685d142633e9df905f66d9401093082d59, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x0f9406b8296564a37304507b8dba3ed162371273a07b1fc98011fcd6ad72205f, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x2360a8eb0cc7defa67b72998de90714e17e75b174a52ee4acb126c8cd995f0a8, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x15871a5cddead976804c803cbaef255eb4815a5e96df8b006dcbbc2767f88948, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x193a56766998ee9e0a8652dd2f3b1da0362f4f54f72379544f957ccdeefb420f, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x2a394a43934f86982f9be56ff4fab1703b2e63c8ad334834e4309805e777ae0f, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x1859954cfeb8695f3e8b635dcb345192892cd11223443ba7b4166e8876c0d142, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x04e1181763050e58013444dbcb99f1902b11bc25d90bbdca408d3819f4fed32b, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x0fdb253dee83869d40c335ea64de8c5bb10eb82db08b5e8b1f5e5552bfd05f23, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x058cbe8a9a5027bdaa4efb623adead6275f08686f1c08984a9d7c5bae9b4f1c0, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x1382edce9971e186497eadb1aeb1f52b23b4b83bef023ab0d15228b4cceca59a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x03464990f045c6ee0819ca51fd11b0be7f61b8eb99f14b77e1e6634601d9e8b5, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x23f7bfc8720dc296fff33b41f98ff83c6fcab4605db2eb5aaa5bc137aeb70a58, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x0a59a158e3eec2117e6e94e7f0e9decf18c3ffd5e1531a9219636158bbaf62f2, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x06ec54c80381c052b58bf23b312ffd3ce2c4eba065420af8f4c23ed0075fd07b, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x118872dc832e0eb5476b56648e867ec8b09340f7a7bcb1b4962f0ff9ed1f9d01, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x13d69fa127d834165ad5c7cba7ad59ed52e0b0f0e42d7fea95e1906b520921b1, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x169a177f63ea681270b1c6877a73d21bde143942fb71dc55fd8a49f19f10c77b, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x04ef51591c6ead97ef42f287adce40d93abeb032b922f66ffb7e9a5a7450544d, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x256e175a1dc079390ecd7ca703fb2e3b19ec61805d4f03ced5f45ee6dd0f69ec, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x30102d28636abd5fe5f2af412ff6004f75cc360d3205dd2da002813d3e2ceeb2, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x10998e42dfcd3bbf1c0714bc73eb1bf40443a3fa99bef4a31fd31be182fcc792, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x193edd8e9fcf3d7625fa7d24b598a1d89f3362eaf4d582efecad76f879e36860, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x18168afd34f2d915d0368ce80b7b3347d1c7a561ce611425f2664d7aa51f0b5d, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x29383c01ebd3b6ab0c017656ebe658b6a328ec77bc33626e29e2e95b33ea6111, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x10646d2f2603de39a1f4ae5e7771a64a702db6e86fb76ab600bf573f9010c711, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x0beb5e07d1b27145f575f1395a55bf132f90c25b40da7b3864d0242dcb1117fb, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x16d685252078c133dc0d3ecad62b5c8830f95bb2e54b59abdffbf018d96fa336, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x0a6abd1d833938f33c74154e0404b4b40a555bbbec21ddfafd672dd62047f01a, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x1a679f5d36eb7b5c8ea12a4c2dedc8feb12dffeec450317270a6f19b34cf1860, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x0980fb233bd456c23974d50e0ebfde4726a423eada4e8f6ffbc7592e3f1b93d6, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x161b42232e61b84cbf1810af93a38fc0cece3d5628c9282003ebacb5c312c72b, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x0ada10a90c7f0520950f7d47a60d5e6a493f09787f1564e5d09203db47de1a0b, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x1a730d372310ba82320345a29ac4238ed3f07a8a2b4e121bb50ddb9af407f451, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x2c8120f268ef054f817064c369dda7ea908377feaba5c4dffbda10ef58e8c556, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x1c7c8824f758753fa57c00789c684217b930e95313bcb73e6e7b8649a4968f70, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x2cd9ed31f5f8691c8e39e4077a74faa0f400ad8b491eb3f7b47b27fa3fd1cf77, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x23ff4f9d46813457cf60d92f57618399a5e022ac321ca550854ae23918a22eea, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x09945a5d147a4f66ceece6405dddd9d0af5a2c5103529407dff1ea58f180426d, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x188d9c528025d4c2b67660c6b771b90f7c7da6eaa29d3f268a6dd223ec6fc630, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x3050e37996596b7f81f68311431d8734dba7d926d3633595e0c0d8ddf4f0f47f, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x15af1169396830a91600ca8102c35c426ceae5461e3f95d89d829518d30afd78, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x1da6d09885432ea9a06d9f37f873d985dae933e351466b2904284da3320d8acc, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := add(0x2796ea90d269af29f5f8acf33921124e4e4fad3dbe658945e546ee411ddaa9cb, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x202d7dd1da0f6b4b0325c8b3307742f01e15612ec8e9304a7cb0319e01d32d60, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x096d6790d05bb759156a952ba263d672a2d7f9c788f4c831a29dace4c0f8be5f, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := add(0x054efa1f65b0fce283808965275d877b438da23ce5b13e1963798cb1447d25a4, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x1b162f83d917e93edb3308c29802deb9d8aa690113b2e14864ccf6e18e4165f1, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x21e5241e12564dd6fd9f1cdd2a0de39eedfefc1466cc568ec5ceb745a0506edc, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := mulmod(scratch1, scratch1, F)
      scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)
      state0 := mulmod(scratch2, scratch2, F)
      scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)
      state0 := add(0x1cfb5662e8cf5ac9226a80ee17b36abecb73ab5f87e161927b4349e10e4bdf08, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x0f21177e302a771bbae6d8d1ecb373b62c99af346220ac0129c53f666eb24100, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x1671522374606992affb0dd7f71b12bec4236aede6290546bcef7e1f515c2320, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := mulmod(state1, state1, F)
      state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)
      scratch0 := mulmod(state2, state2, F)
      state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)
      scratch0 := add(0x0fa3ec5b9488259c2eb4cf24501bfad9be2ec9e42c5cc8ccd419d2a692cad870, add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)))
      scratch1 := add(0x193c0e04e0bd298357cb266c1506080ed36edce85c648cc085e8c57b1ab54bba, add(add(mulmod(state0, M01, F), mulmod(state1, M11, F)), mulmod(state2, M21, F)))
      scratch2 := add(0x102adf8ef74735a27e9128306dcbc3c99f6f7291cd406578ce14ea2adaba68f8, add(add(mulmod(state0, M02, F), mulmod(state1, M12, F)), mulmod(state2, M22, F)))
      state0 := mulmod(scratch0, scratch0, F)
      scratch0 := mulmod(mulmod(state0, state0, F), scratch0, F)
      state0 := mulmod(scratch1, scratch1, F)
      scratch1 := mulmod(mulmod(state0, state0, F), scratch1, F)
      state0 := mulmod(scratch2, scratch2, F)
      scratch2 := mulmod(mulmod(state0, state0, F), scratch2, F)
      state0 := add(0x0fe0af7858e49859e2a54d6f1ad945b1316aa24bfbdd23ae40a6d0cb70c3eab1, add(add(mulmod(scratch0, M00, F), mulmod(scratch1, M10, F)), mulmod(scratch2, M20, F)))
      state1 := add(0x216f6717bbc7dedb08536a2220843f4e2da5f1daa9ebdefde8a5ea7344798d22, add(add(mulmod(scratch0, M01, F), mulmod(scratch1, M11, F)), mulmod(scratch2, M21, F)))
      state2 := add(0x1da55cc900f0d21f4a3e694391918a1b3c23b2ac773c6b3ef88e2e4228325161, add(add(mulmod(scratch0, M02, F), mulmod(scratch1, M12, F)), mulmod(scratch2, M22, F)))
      scratch0 := mulmod(state0, state0, F)
      state0 := mulmod(mulmod(scratch0, scratch0, F), state0, F)
      scratch0 := mulmod(state1, state1, F)
      state1 := mulmod(mulmod(scratch0, scratch0, F), state1, F)
      scratch0 := mulmod(state2, state2, F)
      state2 := mulmod(mulmod(scratch0, scratch0, F), state2, F)

      mstore(0x0, mod(add(add(mulmod(state0, M00, F), mulmod(state1, M10, F)), mulmod(state2, M20, F)), F))

      return(0, 0x20)
    }
  }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 1000
  },
  "evmVersion": "cancun",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {
    "contracts/evm/warptoad/L2WarpToad.sol": {
      "LazyIMT": "0xf97dac6e4434b948a5100e0d420c9f4e6efb9190",
      "PoseidonT3": "0x3333333c0a88f9be4fd23ed0536f9b6c427e3b93"
    }
  }
}

[{"inputs":[{"internalType":"uint8","name":"_maxTreeDepth","type":"uint8"},{"internalType":"address","name":"_withdrawVerifier","type":"address"},{"internalType":"address","name":"_nativeToken","type":"address"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"commitment","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"uint256","name":"_nullifier","type":"uint256"},{"internalType":"uint256","name":"_chainId","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_gigaRoot","type":"uint256"},{"internalType":"uint256","name":"_localRoot","type":"uint256"},{"internalType":"uint256","name":"_aztecWarptoadAddress","type":"uint256"},{"internalType":"uint256","name":"_feeFactor","type":"uint256"},{"internalType":"uint256","name":"_priorityFee","type":"uint256"},{"internalType":"uint256","name":"_maxFee","type":"uint256"},{"internalType":"address","name":"_relayer","type":"address"},{"internalType":"address","name":"_recipient","type":"address"}],"name":"_formatPublicInputs","outputs":[{"internalType":"bytes32[]","name":"","type":"bytes32[]"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"aztecWarptoadAddress","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bridgeRoot","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_preCommitment","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cachedLocalRoot","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"commitTreeData","outputs":[{"internalType":"uint40","name":"maxIndex","type":"uint40"},{"internalType":"uint40","name":"numberOfLeaves","type":"uint40"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"getFreeShit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getLocalRootAndBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"gigaRoot","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"gigaRootHistory","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gigaRootProvider","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_gigaRootProvider","type":"address"},{"internalType":"address","name":"_l1BridgeAdapter","type":"address"},{"internalType":"uint256","name":"_aztecWarptoadAddress","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gigaRoot","type":"uint256"}],"name":"isValidGigaRoot","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_localRoot","type":"uint256"}],"name":"isValidLocalRoot","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l1BridgeAdapter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastLeafIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"localRoot","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"localRootHistory","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTreeDepth","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_nullifier","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_gigaRoot","type":"uint256"},{"internalType":"uint256","name":"_localRoot","type":"uint256"},{"internalType":"uint256","name":"_feeFactor","type":"uint256"},{"internalType":"uint256","name":"_priorityFee","type":"uint256"},{"internalType":"uint256","name":"_maxFee","type":"uint256"},{"internalType":"address","name":"_relayer","type":"address"},{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"bytes","name":"_poof","type":"bytes"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nativeToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_nullifier","type":"uint256"}],"name":"nullifierExists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"nullifiers","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_gigaRoot","type":"uint256"}],"name":"receiveGigaRoot","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"storeLocalRootInHistory","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawVerifier","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

00000000000000000000000000000000000000000000000000000000000000200000000000000000000000008b85ce6330a21fd53a68fa07b025234ee9a371e1000000000000000000000000a0caa84ebff522ec43b7aec844af36c2ccf86c7500000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000019777261707065642d77617270746f61642d55534420436f696e00000000000000000000000000000000000000000000000000000000000000000000000000000a77727074642d5553444300000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _maxTreeDepth (uint8): 32
Arg [1] : _withdrawVerifier (address): 0x8B85CE6330A21Fd53a68fA07b025234ee9a371E1
Arg [2] : _nativeToken (address): 0xa0CAa84ebFf522ec43b7Aec844AF36C2ccF86c75
Arg [3] : name (string): wrapped-warptoad-USD Coin
Arg [4] : symbol (string): wrptd-USDC

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [1] : 0000000000000000000000008b85ce6330a21fd53a68fa07b025234ee9a371e1
Arg [2] : 000000000000000000000000a0caa84ebff522ec43b7aec844af36c2ccf86c75
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [4] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000019
Arg [6] : 777261707065642d77617270746f61642d55534420436f696e00000000000000
Arg [7] : 000000000000000000000000000000000000000000000000000000000000000a
Arg [8] : 77727074642d5553444300000000000000000000000000000000000000000000