diff --git a/.env.sample b/.env.sample new file mode 100644 index 0000000..c599a87 --- /dev/null +++ b/.env.sample @@ -0,0 +1,7 @@ +# Environment variables consumed in Forge scripts (./scripts) + +# RPC URL +RPC_URL=http://localhost:8545 + +# Deployer private key +PRIVATE_KEY=0x... diff --git a/.gas-snapshot b/.gas-snapshot new file mode 100644 index 0000000..0902347 --- /dev/null +++ b/.gas-snapshot @@ -0,0 +1,58 @@ +BalanceScaleTest:testE2E() (gas: 942571) +CoordinatorCallbackTest:testCallbackGasLimitIsApproximatelyCorrect() (gas: 301195) +CoordinatorCallbackTest:testCanCreateCallback() (gas: 142641) +CoordinatorCallbackTest:testCanDeliverCallbackResponse() (gas: 331677) +CoordinatorCallbackTest:testCanDeliverCallbackResponseOnceAcrossTwoNodes() (gas: 505224) +CoordinatorCallbackTest:testCannotDeliverCallbackMaxGasPriceTooLow() (gas: 139387) +CoordinatorCallbackTest:testCannotDeliverCallbackResponseFromSameNodeTwice() (gas: 312437) +CoordinatorCallbackTest:testCannotDeliverCallbackWithInsufficientGasLimit() (gas: 304859) +CoordinatorCallbackTest:testFuzzCannotDeliverCallbackIfIncorrectInterval(uint32) (runs: 256, μ: 139312, ~: 139312) +CoordinatorGeneralTest:testCannotBeReassignedSubscriptionID() (gas: 453861) +CoordinatorGeneralTest:testCannotReceiveResponseFromNonCoordinator() (gas: 11012) +CoordinatorSubscriptionTest:testCanCancelFulfilledSubscription() (gas: 230898) +CoordinatorSubscriptionTest:testCanCancelSubscription() (gas: 87979) +CoordinatorSubscriptionTest:testCanReadContainerInputs() (gas: 13394) +CoordinatorSubscriptionTest:testCannotCancelCancelledSubscription() (gas: 88548) +CoordinatorSubscriptionTest:testCannotCancelNonExistentSubscription() (gas: 14075) +CoordinatorSubscriptionTest:testCannotCancelUnownedSubscription() (gas: 135656) +CoordinatorSubscriptionTest:testCannotDeliverMaxRedundancyResponse() (gas: 452793) +CoordinatorSubscriptionTest:testCannotDeliverResponseDelayed() (gas: 121768) +CoordinatorSubscriptionTest:testCannotDeliverResponseEarly() (gas: 121613) +CoordinatorSubscriptionTest:testCannotDeliverResponseForCompletedSubscription() (gas: 468557) +CoordinatorSubscriptionTest:testCannotDeliverResponseForNonExistentSubscription() (gas: 22024) +CoordinatorSubscriptionTest:testCannotDeliverResponseFromNonNode() (gas: 111969) +CoordinatorSubscriptionTest:testCannotDeliverResponseIfAlreadyDeliveredInCurrentInterval() (gas: 290576) +CoordinatorSubscriptionTest:testCannotDeliverResponseIncorrectInterval() (gas: 289704) +CoordinatorSubscriptionTest:testCannotDeliverResponseNonActiveSubscription() (gas: 131838) +CoordinatorSubscriptionTest:testCannotDeliverSubscriptionWithInsufficientGasLimit() (gas: 282230) +CoordinatorSubscriptionTest:testFuzzSubscriptionIntervalsAreCorrect(uint32,uint32,uint32) (runs: 256, μ: 21641, ~: 14634) +CoordinatorSubscriptionTest:testSubscriptionGasLimitIsApproximatelyCorrect() (gas: 278328) +EIP712CoordinatorTest:testCanAtomicCreateSubscriptionAndDeliverOutput() (gas: 368256) +EIP712CoordinatorTest:testCanCancelSubscriptionCreatedViaDelegate() (gas: 149801) +EIP712CoordinatorTest:testCanCreateDelegatedSubscriptionWithUnorderedNonces() (gas: 336739) +EIP712CoordinatorTest:testCanCreateNewSubscriptionViaEIP712() (gas: 179021) +EIP712CoordinatorTest:testCanDelegatedDeliverComputeResponseForExistingSubscription() (gas: 509659) +EIP712CoordinatorTest:testCanGetExistingSubscriptionViaEIP712() (gas: 186650) +EIP712CoordinatorTest:testCanUseExistingDelegatedSubscriptionFromOldSigner() (gas: 170617) +EIP712CoordinatorTest:testCannotAtomicDeliverOutputForCompletedSubscription() (gas: 368987) +EIP712CoordinatorTest:testCannotCreateDelegatedSubscriptionWhereNonceReused() (gas: 207700) +EIP712CoordinatorTest:testCannotCreateDelegatedSubscriptionWhereSignatureExpired() (gas: 32448) +EIP712CoordinatorTest:testCannotDeliverEIP712SubscriptionWhereGasLimitTooLow() (gas: 338884) +EIP712CoordinatorTest:testCannotUseValidDelegatedSubscriptionFromOldSigner() (gas: 48168) +EIP712CoordinatorTest:testDeliverReducedGasCostSubscriptionCachedSubscription() (gas: 501991) +EIP712CoordinatorTest:testFuzzCannotCreateDelegatedSubscriptionWhereSignatureMismatch(uint256) (runs: 256, μ: 43249, ~: 43249) +ManagerTest:testActivateNode() (gas: 54843) +ManagerTest:testActivateNodeMustReadministerCooldownIfReactivating() (gas: 86779) +ManagerTest:testCanCallOnlyActiveNodeFnAsActiveNode() (gas: 48772) +ManagerTest:testCanDeactivateActiveNode() (gas: 40439) +ManagerTest:testCanDeactivateInactiveNode() (gas: 26121) +ManagerTest:testCanDeactivateRegisteredNode() (gas: 36586) +ManagerTest:testCanRegisterInactiveNode() (gas: 61447) +ManagerTest:testCanRegisterInactiveNodeViaProxy() (gas: 59598) +ManagerTest:testCannnotCallOnlyActiveNodeFnAsInactiveNode() (gas: 16139) +ManagerTest:testCannotActivateInactiveNode() (gas: 16594) +ManagerTest:testCannotCallOnlyActiveNodeFnAsRegisteredNode() (gas: 40810) +ManagerTest:testCannotReactivateNode() (gas: 49335) +ManagerTest:testCannotRegisterActiveNode() (gas: 49924) +ManagerTest:testCannotReregisterNode() (gas: 43382) +ManagerTest:testFuzzCannotActivateNodeBeforeCooldownElapsed(uint256) (runs: 256, μ: 45226, ~: 45226) diff --git a/.github/workflows/test_contracts.yml b/.github/workflows/test_contracts.yml new file mode 100644 index 0000000..23506c4 --- /dev/null +++ b/.github/workflows/test_contracts.yml @@ -0,0 +1,37 @@ +name: Contracts CI + +on: push + +env: + FOUNDRY_PROFILE: ci + +jobs: + run_ci: + strategy: + fail-fast: true + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + with: + submodules: recursive + + - name: Install Foundry + uses: foundry-rs/foundry-toolchain@v1 + with: + version: nightly + + - name: Install contract deps + run: forge --version && forge install + id: install + + - name: Build contracts + run: forge build --sizes + id: build + + - name: Copy compiled artifacts + run: cp -r compiled/. out/ + id: artifacts + + - name: Run tests + run: forge test -vvv + id: test diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ad4d0af --- /dev/null +++ b/.gitignore @@ -0,0 +1,18 @@ +# Compiler files +cache/ +out/ + +# Ignores development broadcast logs +broadcast/ + +# Docs +docs/ + +# Dotenv file +.env + +# VSCode workspace config +.vscode/ + +# OS cache +.DS_Store diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..0f07815 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,6 @@ +[submodule "lib/forge-std"] + path = lib/forge-std + url = https://github.com/foundry-rs/forge-std +[submodule "lib/solady"] + path = lib/solady + url = https://github.com/vectorized/solady diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..9b58e56 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,20 @@ +repos: + # Default pre-commit hooks + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v3.2.0 + hooks: + # Ensure EOF exists + - id: end-of-file-fixer + # Prevent adding large files + - id: check-added-large-files + args: ["--maxkb=5000"] + # Solidity pre-commit hooks + - repo: local + hooks: + - id: lint + name: Lint solidity files via forge fmt + description: Lint solidity code via forge fmt + language: system + stages: [commit] + entry: bash -c 'make format' + pass_filenames: false diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..ab3edd5 --- /dev/null +++ b/LICENSE @@ -0,0 +1,32 @@ +The Clear BSD License + +Copyright (c) 2023 Origin Research Ltd +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted (subject to the limitations in the disclaimer below) provided that +the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + * Neither the name of the copyright holder nor the names of its + contributors may be used to endorse or promote products derived from this + software without specific prior written permission. + +NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY +THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR +BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER +IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..3c4ae1a --- /dev/null +++ b/Makefile @@ -0,0 +1,58 @@ +# Use bash as shell +SHELL := /bin/bash + +# Load environment variables +ifneq (,$(wildcard ./.env)) + include .env + export +endif + +# Phony targets +.PHONY: install clean build test format docs snapshot diff deploy + +# Default: install deps, clean build outputs, format code, build code, run tests +all: install clean format build test + +# Install dependencies +install: + @forge install + +# Clean build outputs +clean: + @forge clean + +# Build contracts + tests +build: + @forge build + @cp -r compiled/. out/ + +# Run tests +test: + @forge test -vvv + +# Execute scripts/deploy given environment variables +deploy: + @forge script scripts/Deploy.sol:Deploy \ + --broadcast \ + --optimize \ + --optimizer-runs 1000000 \ + --extra-output-files abi \ + --rpc-url $(RPC_URL) + +# Save gas snapshot +snapshot: + @forge snapshot + +# Compare current gas profile to saved gas snapshot +diff: + @forge snapshot --diff + +# Format contracts +format: + @forge fmt + +# Generate and serve docs +docs: + @forge doc --build + @open http://localhost:4000 + @forge doc --serve --port 4000 diff --git a/README.md b/README.md new file mode 100644 index 0000000..cfbbfd8 --- /dev/null +++ b/README.md @@ -0,0 +1,131 @@ +# Infernet SDK + +[![Tests](https://github.com/ritual-net/infernet-sdk/actions/workflows/test_contracts.yml/badge.svg)](https://github.com/ritual-net/infernet-sdk/actions/workflows/test_contracts.yml) + +The Infernet SDK is a set of smart contracts from [Ritual](https://ritual.net) that enable on-chain smart contracts to subscribe to off-chain compute workloads. + +Developers can inherit one of two simple interfaces, [`CallbackConsumer`](./src/consumer/Callback.sol) or [`SubscriptionConsumer`](./src/consumer/Subscription.sol) in their smart contracts, and consume one-time or recurring computation. + +> [!IMPORTANT] +> Smart contract architecture, quick-start guides, and in-depth documentation can be found on the [Ritual documentation website](https://docs.ritual.net/infernet/sdk/architecture) + +> [!WARNING] +> These smart contracts are being provided as is. No guarantee, representation or warranty is being made, express or implied, as to the safety or correctness of the smart contracts. + +## Local deployment and usage + +First, ensure you have [Foundry installed locally](https://book.getfoundry.sh/getting-started/installation). A simple way to install is to run the following command: + +```bash +# Install foundryup, follow instructions +curl -L https://foundry.paradigm.xyz | bash +``` + +### Building and running + +To build, run, or execute other commands, you can reference the [Makefile](./Makefile). + +The default target (`make`) will: + +1. Install all dependencies +2. Clean existing build outputs +3. Format code +4. Build code and copy compiled artifacts +5. Run test suite + +### Using within your own contracts + +To import Infernet as a library, you can install the code in your repo with [forge](https://book.getfoundry.sh/forge/): + +```bash +forge install https://github.com/ritual-net/infernet-sdk +``` + +To integrate with the contracts, the available interfaces can be imported from [./src/consumer](./src/consumer/): + +```solidity +import {CallbackConsumer} from "infernet/consumer/Callback.sol"; + +contract MyContract is CallbackConsumer { + function requestSomeComputeResponse() { + // This will create a new one-time callback request for off-chain compute + _requestCompute(...); + } + + function _receiveCompute(...) internal override { + // Here you will receive the off-chain compute response + } +} +``` + +```solidity +import {SubscriptionConsumer} from "infernet/consumer/Subscription.sol"; + +contract MyContract is SubscriptionConsumer { + function scheduleComputeResponse() { + // This will create a new recurring request for off-chain compute + _createComputeSubscription(...); + } + + function cancelScheduledComputeResponse() { + // This will allow you to cancel scheduled requests + _cancelComputeSubscription(...); + } + + function _receiveCompute(...) internal override { + // Here you will receive the off-chain compute output + } +} +``` + +## Repository structure + +```bash +. +├── .env.sample # Sample env variables +├── .gas-snapshot # Function execution gas snapshot +├── Makefile +├── README.md +├── STYLE.md +├── compiled # Pre-compiled artifacts (via solc) +│   └── Verifier.sol +│   ├── Halo2Verifier.json +│   └── Verifier.sol +├── foundry.toml # Foundry setup +├── remappings.txt +├── scripts +│   └── Deploy.sol # EIP712Coordinator deploy script +├── src # Contracts +│   ├── Coordinator.sol # Base coordinator +│   ├── EIP712Coordinator.sol # EIP-712 typed message supporting coordinator +│   ├── Manager.sol # Node manager +│   ├── consumer # Consumers inherited by developers +│   │   ├── Base.sol +│   │   ├── Callback.sol # CallbackConsumer +│   │   └── Subscription.sol # SubscriptionConsumer +│   └── pattern # Useful developer patterns +│   └── Delegator.sol # EIP-712 delegator +└── test # Tests + ├── Coordinator.t.sol + ├── E2E.t.sol + ├── EIP712Coordinator.t.sol + ├── Manager.t.sol + ├── ezkl # E2E tests w/ EZKL-generated proofs + │   ├── BalanceScale.sol + │   └── DataAttestor.sol + ├── lib # Useful libraries + │   ├── LibSign.sol # EIP-712 signing + │   └── LibStruct.sol # Struct parsing + └── mocks + ├── MockManager.sol + ├── MockNode.sol # Mock Infernet node + └── consumer + ├── Base.sol + ├── Callback.sol + ├── DelegatorCallback.sol + └── Subscription.sol +``` + +## License + +[BSD 3-clause Clear](./LICENSE) diff --git a/STYLE.md b/STYLE.md new file mode 100644 index 0000000..c537e06 --- /dev/null +++ b/STYLE.md @@ -0,0 +1,134 @@ +# Solidity Style Guide + +Generally follows the [Solidity Style Guide](https://docs.soliditylang.org/en/latest/style-guide.html) with a few exceptions. + +By default, running `make format` will run the formatter forcing conformation to _most_ of the style guide. + +## Custom rules, overrides + +### Maximum line length + +Ideally, each function argument should fall on its own line. For example: + +```solidity +thisFunctionCallIsReallyLong( + longArgument1, + longArgument2, + longArgument3 +); +``` + +For the time-being, default `make format` line-breaking is acceptable for uniformity. This is based on a fixed line length of `120` characters instead. + +### Imports + +Sort imports by length. + +```solidity +// Bad +import {Manager} from "./Manager.sol"; +import {Token} from "./Token.sol"; +import {BaseConsumer} from "./consumer/Base.sol"; + +// Good +import {Token} from "./Token.sol"; +import {Manager} from "./Manager.sol"; +import {BaseConsumer} from "./consumer/Base.sol"; +``` + +### Section ordering + +Ordering of sections in contract goes: + +1. SPDX identifier +2. Imports +3. Contract definition +4. Structs +5. Enums +6. Constants +7. Immutable variables +8. Mutable variables +9. Events +10. Errors +11. Modifiers +12. Constructor +13. Internal functions +14. External functions + +Sections are delineated using headers generated from [transmissions11/headers](https://github.com/transmissions11/headers). + +### Control structures + +1. Always wrap `if` statements in closures +2. Do not use one-line statements + +```solidity +// Bad +if (value == 0) return 1; + +// Good +if (value == 0) { + return 1; +} +``` + +### Function declaration + +Always explitly return variables from functions. + +```solidity +// Bad +function test() external returns (uint256 myVar) { + myVar = 1; +} + +// Good +function test() external returns (uint256) { + myVar = 1; + return myVar; +} +``` + +### Prefer least visibility, when possible + +Prefer `private` > `internal` > `external` > `public`, to best discretion. + +## General recommendations + +### Naming + +1. Prefer `camelCase`. +2. For constants, immutables, and values that should act as constants or immutables (in cases where you can't initialize as such, like tests), prefer `ALL_CAPS_CONSTANTS`. +3. Function names should start with imperative verbs +4. Functions with `internal` visibility should be prefixed with an underscore: `_internalFunction`. This is not necessary for variables + +### Variables + +1. Explicitly declare variable sizes (no `uint`) +2. Prefer smallest variable size by default (eg `uint32` for timestamp over `uint256`), unless in special cases where casting overhead is expensive or readability impact of switching is low +3. Declare in order `type visibility mutability name`, eg `address internal immutable myContractAddress` + +### Constructor + +1. Start constructor parameters with `_underscore` +2. Prefer typed contract inheritance (eg `Type myContract` over `address myContractAddress`) +3. Ignore (2) when setting up developer-facing interfaces. It's easier for developers to not have to worry about the initialization. + +### Errors + +Use custom errors. + +### Events + +1. Choose to emit events liberally. +2. Think through what data would be useful to index off-chain when determining event parameters. + +### Assembly + +1. Generally, avoid unless significant optimizations possible +2. Comment all memory layouts +3. Use only `memory-safe` assembly; mark assembly blocks as such + +## Misc + +1. Prefer two-step processes (`ownership` transfer, joining as a node) over one step to reduce chance for human error diff --git a/compiled/Verifier.sol/Halo2Verifier.json b/compiled/Verifier.sol/Halo2Verifier.json new file mode 100644 index 0000000..54dd479 --- /dev/null +++ b/compiled/Verifier.sol/Halo2Verifier.json @@ -0,0 +1,43144 @@ +{ + "abi": [ + { + "inputs": [ + { "internalType": "bytes", "name": "proof", "type": "bytes" }, + { + "internalType": "uint256[]", + "name": "instances", + "type": "uint256[]" + } + ], + "name": "verifyProof", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "bytecode": { + "object": "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", + "sourceMap": "58:63564:0:-:0;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;:::o;:::-;;;", + "linkReferences": {} + }, + "deployedBytecode": { + "object": "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", + "sourceMap": "58:63564:0:-:0;;;;;;;;;-1:-1:-1;58:63564:0;:::i;:::-;;;;;:::i;:::-;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;:::i;:::-;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::o;3519:60095::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;3392:60228::-;;;;;3503:4;;:::i;:::-;3519:60095;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;;;:::i;:::-;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;", + "linkReferences": {} + }, + "methodIdentifiers": { + "verifyProof(bytes,uint256[])": "1e8e1e13" + }, + "rawMetadata": "{\"compiler\":{\"version\":\"0.8.21+commit.d9974bed\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"proof\",\"type\":\"bytes\"},{\"internalType\":\"uint256[]\",\"name\":\"instances\",\"type\":\"uint256[]\"}],\"name\":\"verifyProof\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"Verifier.sol\":\"Halo2Verifier\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[],\"viaIR\":true},\"sources\":{\"Verifier.sol\":{\"keccak256\":\"0xf70500b76dabf2bfde7105c907d08c4b887070b40c59d037cca12239ce82ae6c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ddaecf10ab193f30b94dcf859e89cfcef76e3991e17610e50a0c9b1e9f561778\",\"dweb:/ipfs/QmbvyHsxq72FWJgLitvsfmHNRMiVjtxzNDk43tqTWV3eNc\"]}},\"version\":1}", + "metadata": { + "compiler": { "version": "0.8.21+commit.d9974bed" }, + "language": "Solidity", + "output": { + "abi": [ + { + "inputs": [ + { "internalType": "bytes", "name": "proof", "type": "bytes" }, + { + "internalType": "uint256[]", + "name": "instances", + "type": "uint256[]" + } + ], + "name": "verifyProof", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "nonpayable", + "type": "function" + } + ], + "devdoc": { "kind": "dev", "methods": {}, "version": 1 }, + "userdoc": { "kind": "user", "methods": {}, "version": 1 } + }, + "settings": { + "compilationTarget": { "Verifier.sol": "Halo2Verifier" }, + "evmVersion": "paris", + "libraries": {}, + "metadata": { "bytecodeHash": "ipfs" }, + "optimizer": { "enabled": false, "runs": 200 }, + "remappings": [], + "viaIR": true + }, + "sources": { + "Verifier.sol": { + "keccak256": "0xf70500b76dabf2bfde7105c907d08c4b887070b40c59d037cca12239ce82ae6c", + "license": "MIT", + "urls": [ + "bzz-raw://ddaecf10ab193f30b94dcf859e89cfcef76e3991e17610e50a0c9b1e9f561778", + "dweb:/ipfs/QmbvyHsxq72FWJgLitvsfmHNRMiVjtxzNDk43tqTWV3eNc" + ] + } + }, + "version": 1 + }, + "ast": { + "absolutePath": "Verifier.sol", + "exportedSymbols": { "Halo2Verifier": [179] }, + "id": 180, + "license": "MIT", + "nodeType": "SourceUnit", + "nodes": [ + { + "id": 1, + "literals": ["solidity", "^", "0.8", ".0"], + "nodeType": "PragmaDirective", + "src": "33:23:0" + }, + { + "abstract": false, + "baseContracts": [], + "canonicalName": "Halo2Verifier", + "contractDependencies": [], + "contractKind": "contract", + "fullyImplemented": true, + "id": 179, + "linearizedBaseContracts": [179], + "name": "Halo2Verifier", + "nameLocation": "67:13:0", + "nodeType": "ContractDefinition", + "nodes": [ + { + "constant": true, + "id": 4, + "mutability": "constant", + "name": "PROOF_LEN_CPTR", + "nameLocation": "116:14:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "87:50:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 2, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "87:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "30783434", + "id": 3, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "133:4:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_68_by_1", + "typeString": "int_const 68" + }, + "value": "0x44" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 7, + "mutability": "constant", + "name": "PROOF_CPTR", + "nameLocation": "176:10:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "143:50:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 5, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "143:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "30783634", + "id": 6, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "189:4:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_100_by_1", + "typeString": "int_const 100" + }, + "value": "0x64" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 10, + "mutability": "constant", + "name": "NUM_INSTANCE_CPTR", + "nameLocation": "225:17:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "199:52:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 8, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "199:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830393634", + "id": 9, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "245:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_2404_by_1", + "typeString": "int_const 2404" + }, + "value": "0x0964" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 13, + "mutability": "constant", + "name": "INSTANCE_CPTR", + "nameLocation": "287:13:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "257:52:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 11, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "257:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830393834", + "id": 12, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "303:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_2436_by_1", + "typeString": "int_const 2436" + }, + "value": "0x0984" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 16, + "mutability": "constant", + "name": "FIRST_QUOTIENT_X_CPTR", + "nameLocation": "342:21:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "316:56:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 14, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "316:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830333634", + "id": 15, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "366:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_868_by_1", + "typeString": "int_const 868" + }, + "value": "0x0364" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 19, + "mutability": "constant", + "name": "LAST_QUOTIENT_X_CPTR", + "nameLocation": "405:20:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "378:56:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 17, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "378:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830343234", + "id": 18, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "428:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1060_by_1", + "typeString": "int_const 1060" + }, + "value": "0x0424" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 22, + "mutability": "constant", + "name": "VK_MPTR", + "nameLocation": "482:7:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "441:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 20, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "441:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830356130", + "id": 21, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "492:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1440_by_1", + "typeString": "int_const 1440" + }, + "value": "0x05a0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 25, + "mutability": "constant", + "name": "VK_DIGEST_MPTR", + "nameLocation": "538:14:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "504:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 23, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "504:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830356130", + "id": 24, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "555:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1440_by_1", + "typeString": "int_const 1440" + }, + "value": "0x05a0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 28, + "mutability": "constant", + "name": "K_MPTR", + "nameLocation": "609:6:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "567:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 26, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "567:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830356330", + "id": 27, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "618:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1472_by_1", + "typeString": "int_const 1472" + }, + "value": "0x05c0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 31, + "mutability": "constant", + "name": "N_INV_MPTR", + "nameLocation": "668:10:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "630:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 29, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "630:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830356530", + "id": 30, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "681:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1504_by_1", + "typeString": "int_const 1504" + }, + "value": "0x05e0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 34, + "mutability": "constant", + "name": "OMEGA_MPTR", + "nameLocation": "731:10:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "693:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 32, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "693:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830363030", + "id": 33, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "744:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1536_by_1", + "typeString": "int_const 1536" + }, + "value": "0x0600" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 37, + "mutability": "constant", + "name": "OMEGA_INV_MPTR", + "nameLocation": "790:14:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "756:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 35, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "756:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830363230", + "id": 36, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "807:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1568_by_1", + "typeString": "int_const 1568" + }, + "value": "0x0620" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 40, + "mutability": "constant", + "name": "OMEGA_INV_TO_L_MPTR", + "nameLocation": "848:19:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "819:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 38, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "819:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830363430", + "id": 39, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "870:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1600_by_1", + "typeString": "int_const 1600" + }, + "value": "0x0640" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 43, + "mutability": "constant", + "name": "NUM_INSTANCES_MPTR", + "nameLocation": "912:18:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "882:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 41, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "882:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830363630", + "id": 42, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "933:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1632_by_1", + "typeString": "int_const 1632" + }, + "value": "0x0660" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 46, + "mutability": "constant", + "name": "HAS_ACCUMULATOR_MPTR", + "nameLocation": "973:20:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "945:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 44, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "945:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830363830", + "id": 45, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "996:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1664_by_1", + "typeString": "int_const 1664" + }, + "value": "0x0680" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 49, + "mutability": "constant", + "name": "ACC_OFFSET_MPTR", + "nameLocation": "1041:15:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1008:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 47, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1008:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830366130", + "id": 48, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1059:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1696_by_1", + "typeString": "int_const 1696" + }, + "value": "0x06a0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 52, + "mutability": "constant", + "name": "NUM_ACC_LIMBS_MPTR", + "nameLocation": "1101:18:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1071:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 50, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1071:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830366330", + "id": 51, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1122:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1728_by_1", + "typeString": "int_const 1728" + }, + "value": "0x06c0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 55, + "mutability": "constant", + "name": "NUM_ACC_LIMB_BITS_MPTR", + "nameLocation": "1160:22:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1134:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 53, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1134:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830366530", + "id": 54, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1185:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1760_by_1", + "typeString": "int_const 1760" + }, + "value": "0x06e0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 58, + "mutability": "constant", + "name": "G1_X_MPTR", + "nameLocation": "1236:9:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1197:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 56, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1197:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830373030", + "id": 57, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1248:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1792_by_1", + "typeString": "int_const 1792" + }, + "value": "0x0700" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 61, + "mutability": "constant", + "name": "G1_Y_MPTR", + "nameLocation": "1299:9:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1260:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 59, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1260:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830373230", + "id": 60, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1311:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1824_by_1", + "typeString": "int_const 1824" + }, + "value": "0x0720" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 64, + "mutability": "constant", + "name": "G2_X_1_MPTR", + "nameLocation": "1360:11:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1323:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 62, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1323:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830373430", + "id": 63, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1374:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1856_by_1", + "typeString": "int_const 1856" + }, + "value": "0x0740" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 67, + "mutability": "constant", + "name": "G2_X_2_MPTR", + "nameLocation": "1423:11:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1386:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 65, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1386:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830373630", + "id": 66, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1437:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1888_by_1", + "typeString": "int_const 1888" + }, + "value": "0x0760" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 70, + "mutability": "constant", + "name": "G2_Y_1_MPTR", + "nameLocation": "1486:11:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1449:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 68, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1449:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830373830", + "id": 69, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1500:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1920_by_1", + "typeString": "int_const 1920" + }, + "value": "0x0780" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 73, + "mutability": "constant", + "name": "G2_Y_2_MPTR", + "nameLocation": "1549:11:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1512:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 71, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1512:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830376130", + "id": 72, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1563:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1952_by_1", + "typeString": "int_const 1952" + }, + "value": "0x07a0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 76, + "mutability": "constant", + "name": "NEG_S_G2_X_1_MPTR", + "nameLocation": "1606:17:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1575:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 74, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1575:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830376330", + "id": 75, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1626:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_1984_by_1", + "typeString": "int_const 1984" + }, + "value": "0x07c0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 79, + "mutability": "constant", + "name": "NEG_S_G2_X_2_MPTR", + "nameLocation": "1669:17:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1638:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 77, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1638:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830376530", + "id": 78, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1689:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_2016_by_1", + "typeString": "int_const 2016" + }, + "value": "0x07e0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 82, + "mutability": "constant", + "name": "NEG_S_G2_Y_1_MPTR", + "nameLocation": "1732:17:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1701:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 80, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1701:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830383030", + "id": 81, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1752:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_2048_by_1", + "typeString": "int_const 2048" + }, + "value": "0x0800" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 85, + "mutability": "constant", + "name": "NEG_S_G2_Y_2_MPTR", + "nameLocation": "1795:17:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1764:57:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 83, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1764:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830383230", + "id": 84, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1815:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_2080_by_1", + "typeString": "int_const 2080" + }, + "value": "0x0820" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 88, + "mutability": "constant", + "name": "CHALLENGE_MPTR", + "nameLocation": "1854:14:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1828:49:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 86, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1828:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830633830", + "id": 87, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1871:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3200_by_1", + "typeString": "int_const 3200" + }, + "value": "0x0c80" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 91, + "mutability": "constant", + "name": "THETA_MPTR", + "nameLocation": "1910:10:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1884:45:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 89, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1884:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830633830", + "id": 90, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1923:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3200_by_1", + "typeString": "int_const 3200" + }, + "value": "0x0c80" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 94, + "mutability": "constant", + "name": "BETA_MPTR", + "nameLocation": "1962:9:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1935:45:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 92, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1935:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830636130", + "id": 93, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "1974:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3232_by_1", + "typeString": "int_const 3232" + }, + "value": "0x0ca0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 97, + "mutability": "constant", + "name": "GAMMA_MPTR", + "nameLocation": "2012:10:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "1986:45:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 95, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "1986:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830636330", + "id": 96, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2025:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3264_by_1", + "typeString": "int_const 3264" + }, + "value": "0x0cc0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 100, + "mutability": "constant", + "name": "Y_MPTR", + "nameLocation": "2067:6:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2037:45:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 98, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2037:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830636530", + "id": 99, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2076:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3296_by_1", + "typeString": "int_const 3296" + }, + "value": "0x0ce0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 103, + "mutability": "constant", + "name": "X_MPTR", + "nameLocation": "2118:6:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2088:45:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 101, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2088:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830643030", + "id": 102, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2127:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3328_by_1", + "typeString": "int_const 3328" + }, + "value": "0x0d00" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 106, + "mutability": "constant", + "name": "ZETA_MPTR", + "nameLocation": "2166:9:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2139:45:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 104, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2139:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830643230", + "id": 105, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2178:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3360_by_1", + "typeString": "int_const 3360" + }, + "value": "0x0d20" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 109, + "mutability": "constant", + "name": "NU_MPTR", + "nameLocation": "2219:7:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2190:45:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 107, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2190:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830643430", + "id": 108, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2229:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3392_by_1", + "typeString": "int_const 3392" + }, + "value": "0x0d40" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 112, + "mutability": "constant", + "name": "MU_MPTR", + "nameLocation": "2270:7:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2241:45:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 110, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2241:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830643630", + "id": 111, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2280:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3424_by_1", + "typeString": "int_const 3424" + }, + "value": "0x0d60" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 115, + "mutability": "constant", + "name": "ACC_LHS_X_MPTR", + "nameLocation": "2325:14:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2293:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 113, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2293:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830643830", + "id": 114, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2342:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3456_by_1", + "typeString": "int_const 3456" + }, + "value": "0x0d80" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 118, + "mutability": "constant", + "name": "ACC_LHS_Y_MPTR", + "nameLocation": "2386:14:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2354:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 116, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2354:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830646130", + "id": 117, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2403:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3488_by_1", + "typeString": "int_const 3488" + }, + "value": "0x0da0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 121, + "mutability": "constant", + "name": "ACC_RHS_X_MPTR", + "nameLocation": "2447:14:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2415:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 119, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2415:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830646330", + "id": 120, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2464:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3520_by_1", + "typeString": "int_const 3520" + }, + "value": "0x0dc0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 124, + "mutability": "constant", + "name": "ACC_RHS_Y_MPTR", + "nameLocation": "2508:14:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2476:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 122, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2476:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830646530", + "id": 123, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2525:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3552_by_1", + "typeString": "int_const 3552" + }, + "value": "0x0de0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 127, + "mutability": "constant", + "name": "X_N_MPTR", + "nameLocation": "2575:8:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2537:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 125, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2537:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830653030", + "id": 126, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2586:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3584_by_1", + "typeString": "int_const 3584" + }, + "value": "0x0e00" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 130, + "mutability": "constant", + "name": "X_N_MINUS_1_INV_MPTR", + "nameLocation": "2624:20:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2598:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 128, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2598:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830653230", + "id": 129, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2647:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3616_by_1", + "typeString": "int_const 3616" + }, + "value": "0x0e20" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 133, + "mutability": "constant", + "name": "L_LAST_MPTR", + "nameLocation": "2694:11:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2659:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 131, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2659:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830653430", + "id": 132, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2708:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3648_by_1", + "typeString": "int_const 3648" + }, + "value": "0x0e40" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 136, + "mutability": "constant", + "name": "L_BLIND_MPTR", + "nameLocation": "2754:12:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2720:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 134, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2720:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830653630", + "id": 135, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2769:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3680_by_1", + "typeString": "int_const 3680" + }, + "value": "0x0e60" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 139, + "mutability": "constant", + "name": "L_0_MPTR", + "nameLocation": "2819:8:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2781:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 137, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2781:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830653830", + "id": 138, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2830:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3712_by_1", + "typeString": "int_const 3712" + }, + "value": "0x0e80" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 142, + "mutability": "constant", + "name": "INSTANCE_EVAL_MPTR", + "nameLocation": "2870:18:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2842:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 140, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2842:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830656130", + "id": 141, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2891:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3744_by_1", + "typeString": "int_const 3744" + }, + "value": "0x0ea0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 145, + "mutability": "constant", + "name": "QUOTIENT_EVAL_MPTR", + "nameLocation": "2931:18:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2903:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 143, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2903:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830656330", + "id": 144, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "2952:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3776_by_1", + "typeString": "int_const 3776" + }, + "value": "0x0ec0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 148, + "mutability": "constant", + "name": "QUOTIENT_X_MPTR", + "nameLocation": "2995:15:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "2964:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 146, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "2964:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830656530", + "id": 147, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "3013:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3808_by_1", + "typeString": "int_const 3808" + }, + "value": "0x0ee0" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 151, + "mutability": "constant", + "name": "QUOTIENT_Y_MPTR", + "nameLocation": "3056:15:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "3025:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 149, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "3025:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830663030", + "id": 150, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "3074:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3840_by_1", + "typeString": "int_const 3840" + }, + "value": "0x0f00" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 154, + "mutability": "constant", + "name": "R_EVAL_MPTR", + "nameLocation": "3121:11:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "3086:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 152, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "3086:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830663230", + "id": 153, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "3135:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3872_by_1", + "typeString": "int_const 3872" + }, + "value": "0x0f20" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 157, + "mutability": "constant", + "name": "PAIRING_LHS_X_MPTR", + "nameLocation": "3175:18:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "3147:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 155, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "3147:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830663430", + "id": 156, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "3196:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3904_by_1", + "typeString": "int_const 3904" + }, + "value": "0x0f40" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 160, + "mutability": "constant", + "name": "PAIRING_LHS_Y_MPTR", + "nameLocation": "3236:18:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "3208:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 158, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "3208:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830663630", + "id": 159, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "3257:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3936_by_1", + "typeString": "int_const 3936" + }, + "value": "0x0f60" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 163, + "mutability": "constant", + "name": "PAIRING_RHS_X_MPTR", + "nameLocation": "3297:18:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "3269:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 161, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "3269:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830663830", + "id": 162, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "3318:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_3968_by_1", + "typeString": "int_const 3968" + }, + "value": "0x0f80" + }, + "visibility": "internal" + }, + { + "constant": true, + "id": 166, + "mutability": "constant", + "name": "PAIRING_RHS_Y_MPTR", + "nameLocation": "3358:18:0", + "nodeType": "VariableDeclaration", + "scope": 179, + "src": "3330:55:0", + "stateVariable": true, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + }, + "typeName": { + "id": 164, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "3330:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "value": { + "hexValue": "307830666130", + "id": 165, + "isConstant": false, + "isLValue": false, + "isPure": true, + "kind": "number", + "lValueRequested": false, + "nodeType": "Literal", + "src": "3379:6:0", + "typeDescriptions": { + "typeIdentifier": "t_rational_4000_by_1", + "typeString": "int_const 4000" + }, + "value": "0x0fa0" + }, + "visibility": "internal" + }, + { + "body": { + "id": 177, + "nodeType": "Block", + "src": "3509:60111:0", + "statements": [ + { + "AST": { + "nativeSrc": "3528:60086:0", + "nodeType": "YulBlock", + "src": "3528:60086:0", + "statements": [ + { + "body": { + "nativeSrc": "3878:493:0", + "nodeType": "YulBlock", + "src": "3878:493:0", + "statements": [ + { + "nativeSrc": "3896:33:0", + "nodeType": "YulVariableDeclaration", + "src": "3896:33:0", + "value": { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "3918:10:0", + "nodeType": "YulIdentifier", + "src": "3918:10:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "3905:12:0", + "nodeType": "YulIdentifier", + "src": "3905:12:0" + }, + "nativeSrc": "3905:24:0", + "nodeType": "YulFunctionCall", + "src": "3905:24:0" + }, + "variables": [ + { + "name": "x", + "nativeSrc": "3900:1:0", + "nodeType": "YulTypedName", + "src": "3900:1:0", + "type": "" + } + ] + }, + { + "nativeSrc": "3946:44:0", + "nodeType": "YulVariableDeclaration", + "src": "3946:44:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "3972:10:0", + "nodeType": "YulIdentifier", + "src": "3972:10:0" + }, + { + "kind": "number", + "nativeSrc": "3984:4:0", + "nodeType": "YulLiteral", + "src": "3984:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "3968:3:0", + "nodeType": "YulIdentifier", + "src": "3968:3:0" + }, + "nativeSrc": "3968:21:0", + "nodeType": "YulFunctionCall", + "src": "3968:21:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "3955:12:0", + "nodeType": "YulIdentifier", + "src": "3955:12:0" + }, + "nativeSrc": "3955:35:0", + "nodeType": "YulFunctionCall", + "src": "3955:35:0" + }, + "variables": [ + { + "name": "y", + "nativeSrc": "3950:1:0", + "nodeType": "YulTypedName", + "src": "3950:1:0", + "type": "" + } + ] + }, + { + "nativeSrc": "4007:30:0", + "nodeType": "YulAssignment", + "src": "4007:30:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "4019:7:0", + "nodeType": "YulIdentifier", + "src": "4019:7:0" + }, + { + "arguments": [ + { + "name": "x", + "nativeSrc": "4031:1:0", + "nodeType": "YulIdentifier", + "src": "4031:1:0" + }, + { + "name": "q", + "nativeSrc": "4034:1:0", + "nodeType": "YulIdentifier", + "src": "4034:1:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "4028:2:0", + "nodeType": "YulIdentifier", + "src": "4028:2:0" + }, + "nativeSrc": "4028:8:0", + "nodeType": "YulFunctionCall", + "src": "4028:8:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "4015:3:0", + "nodeType": "YulIdentifier", + "src": "4015:3:0" + }, + "nativeSrc": "4015:22:0", + "nodeType": "YulFunctionCall", + "src": "4015:22:0" + }, + "variableNames": [ + { + "name": "ret0", + "nativeSrc": "4007:4:0", + "nodeType": "YulIdentifier", + "src": "4007:4:0" + } + ] + }, + { + "nativeSrc": "4054:27:0", + "nodeType": "YulAssignment", + "src": "4054:27:0", + "value": { + "arguments": [ + { + "name": "ret0", + "nativeSrc": "4066:4:0", + "nodeType": "YulIdentifier", + "src": "4066:4:0" + }, + { + "arguments": [ + { + "name": "y", + "nativeSrc": "4075:1:0", + "nodeType": "YulIdentifier", + "src": "4075:1:0" + }, + { + "name": "q", + "nativeSrc": "4078:1:0", + "nodeType": "YulIdentifier", + "src": "4078:1:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "4072:2:0", + "nodeType": "YulIdentifier", + "src": "4072:2:0" + }, + "nativeSrc": "4072:8:0", + "nodeType": "YulFunctionCall", + "src": "4072:8:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "4062:3:0", + "nodeType": "YulIdentifier", + "src": "4062:3:0" + }, + "nativeSrc": "4062:19:0", + "nodeType": "YulFunctionCall", + "src": "4062:19:0" + }, + "variableNames": [ + { + "name": "ret0", + "nativeSrc": "4054:4:0", + "nodeType": "YulIdentifier", + "src": "4054:4:0" + } + ] + }, + { + "nativeSrc": "4098:83:0", + "nodeType": "YulAssignment", + "src": "4098:83:0", + "value": { + "arguments": [ + { + "name": "ret0", + "nativeSrc": "4110:4:0", + "nodeType": "YulIdentifier", + "src": "4110:4:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "y", + "nativeSrc": "4126:1:0", + "nodeType": "YulIdentifier", + "src": "4126:1:0" + }, + { + "name": "y", + "nativeSrc": "4129:1:0", + "nodeType": "YulIdentifier", + "src": "4129:1:0" + }, + { + "name": "q", + "nativeSrc": "4132:1:0", + "nodeType": "YulIdentifier", + "src": "4132:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "4119:6:0", + "nodeType": "YulIdentifier", + "src": "4119:6:0" + }, + "nativeSrc": "4119:15:0", + "nodeType": "YulFunctionCall", + "src": "4119:15:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "x", + "nativeSrc": "4150:1:0", + "nodeType": "YulIdentifier", + "src": "4150:1:0" + }, + { + "arguments": [ + { + "name": "x", + "nativeSrc": "4160:1:0", + "nodeType": "YulIdentifier", + "src": "4160:1:0" + }, + { + "name": "x", + "nativeSrc": "4163:1:0", + "nodeType": "YulIdentifier", + "src": "4163:1:0" + }, + { + "name": "q", + "nativeSrc": "4166:1:0", + "nodeType": "YulIdentifier", + "src": "4166:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "4153:6:0", + "nodeType": "YulIdentifier", + "src": "4153:6:0" + }, + "nativeSrc": "4153:15:0", + "nodeType": "YulFunctionCall", + "src": "4153:15:0" + }, + { + "name": "q", + "nativeSrc": "4170:1:0", + "nodeType": "YulIdentifier", + "src": "4170:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "4143:6:0", + "nodeType": "YulIdentifier", + "src": "4143:6:0" + }, + "nativeSrc": "4143:29:0", + "nodeType": "YulFunctionCall", + "src": "4143:29:0" + }, + { + "kind": "number", + "nativeSrc": "4174:1:0", + "nodeType": "YulLiteral", + "src": "4174:1:0", + "type": "", + "value": "3" + }, + { + "name": "q", + "nativeSrc": "4177:1:0", + "nodeType": "YulIdentifier", + "src": "4177:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "4136:6:0", + "nodeType": "YulIdentifier", + "src": "4136:6:0" + }, + "nativeSrc": "4136:43:0", + "nodeType": "YulFunctionCall", + "src": "4136:43:0" + } + ], + "functionName": { + "name": "eq", + "nativeSrc": "4116:2:0", + "nodeType": "YulIdentifier", + "src": "4116:2:0" + }, + "nativeSrc": "4116:64:0", + "nodeType": "YulFunctionCall", + "src": "4116:64:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "4106:3:0", + "nodeType": "YulIdentifier", + "src": "4106:3:0" + }, + "nativeSrc": "4106:75:0", + "nodeType": "YulFunctionCall", + "src": "4106:75:0" + }, + "variableNames": [ + { + "name": "ret0", + "nativeSrc": "4098:4:0", + "nodeType": "YulIdentifier", + "src": "4098:4:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "hash_mptr", + "nativeSrc": "4205:9:0", + "nodeType": "YulIdentifier", + "src": "4205:9:0" + }, + { + "name": "x", + "nativeSrc": "4216:1:0", + "nodeType": "YulIdentifier", + "src": "4216:1:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "4198:6:0", + "nodeType": "YulIdentifier", + "src": "4198:6:0" + }, + "nativeSrc": "4198:20:0", + "nodeType": "YulFunctionCall", + "src": "4198:20:0" + }, + "nativeSrc": "4198:20:0", + "nodeType": "YulExpressionStatement", + "src": "4198:20:0" + }, + { + "expression": { + "arguments": [ + { + "arguments": [ + { + "name": "hash_mptr", + "nativeSrc": "4246:9:0", + "nodeType": "YulIdentifier", + "src": "4246:9:0" + }, + { + "kind": "number", + "nativeSrc": "4257:4:0", + "nodeType": "YulLiteral", + "src": "4257:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "4242:3:0", + "nodeType": "YulIdentifier", + "src": "4242:3:0" + }, + "nativeSrc": "4242:20:0", + "nodeType": "YulFunctionCall", + "src": "4242:20:0" + }, + { + "name": "y", + "nativeSrc": "4264:1:0", + "nodeType": "YulIdentifier", + "src": "4264:1:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "4235:6:0", + "nodeType": "YulIdentifier", + "src": "4235:6:0" + }, + "nativeSrc": "4235:31:0", + "nodeType": "YulFunctionCall", + "src": "4235:31:0" + }, + "nativeSrc": "4235:31:0", + "nodeType": "YulExpressionStatement", + "src": "4235:31:0" + }, + { + "nativeSrc": "4283:29:0", + "nodeType": "YulAssignment", + "src": "4283:29:0", + "value": { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "4295:10:0", + "nodeType": "YulIdentifier", + "src": "4295:10:0" + }, + { + "kind": "number", + "nativeSrc": "4307:4:0", + "nodeType": "YulLiteral", + "src": "4307:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "4291:3:0", + "nodeType": "YulIdentifier", + "src": "4291:3:0" + }, + "nativeSrc": "4291:21:0", + "nodeType": "YulFunctionCall", + "src": "4291:21:0" + }, + "variableNames": [ + { + "name": "ret1", + "nativeSrc": "4283:4:0", + "nodeType": "YulIdentifier", + "src": "4283:4:0" + } + ] + }, + { + "nativeSrc": "4329:28:0", + "nodeType": "YulAssignment", + "src": "4329:28:0", + "value": { + "arguments": [ + { + "name": "hash_mptr", + "nativeSrc": "4341:9:0", + "nodeType": "YulIdentifier", + "src": "4341:9:0" + }, + { + "kind": "number", + "nativeSrc": "4352:4:0", + "nodeType": "YulLiteral", + "src": "4352:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "4337:3:0", + "nodeType": "YulIdentifier", + "src": "4337:3:0" + }, + "nativeSrc": "4337:20:0", + "nodeType": "YulFunctionCall", + "src": "4337:20:0" + }, + "variableNames": [ + { + "name": "ret2", + "nativeSrc": "4329:4:0", + "nodeType": "YulIdentifier", + "src": "4329:4:0" + } + ] + } + ] + }, + "name": "read_ec_point", + "nativeSrc": "3800:571:0", + "nodeType": "YulFunctionDefinition", + "parameters": [ + { + "name": "success", + "nativeSrc": "3823:7:0", + "nodeType": "YulTypedName", + "src": "3823:7:0", + "type": "" + }, + { + "name": "proof_cptr", + "nativeSrc": "3832:10:0", + "nodeType": "YulTypedName", + "src": "3832:10:0", + "type": "" + }, + { + "name": "hash_mptr", + "nativeSrc": "3844:9:0", + "nodeType": "YulTypedName", + "src": "3844:9:0", + "type": "" + }, + { + "name": "q", + "nativeSrc": "3855:1:0", + "nodeType": "YulTypedName", + "src": "3855:1:0", + "type": "" + } + ], + "returnVariables": [ + { + "name": "ret0", + "nativeSrc": "3861:4:0", + "nodeType": "YulTypedName", + "src": "3861:4:0", + "type": "" + }, + { + "name": "ret1", + "nativeSrc": "3867:4:0", + "nodeType": "YulTypedName", + "src": "3867:4:0", + "type": "" + }, + { + "name": "ret2", + "nativeSrc": "3873:4:0", + "nodeType": "YulTypedName", + "src": "3873:4:0", + "type": "" + } + ], + "src": "3800:571:0" + }, + { + "body": { + "nativeSrc": "4731:237:0", + "nodeType": "YulBlock", + "src": "4731:237:0", + "statements": [ + { + "nativeSrc": "4749:38:0", + "nodeType": "YulVariableDeclaration", + "src": "4749:38:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "4771:4:0", + "nodeType": "YulLiteral", + "src": "4771:4:0", + "type": "", + "value": "0x00" + }, + { + "name": "hash_mptr", + "nativeSrc": "4777:9:0", + "nodeType": "YulIdentifier", + "src": "4777:9:0" + } + ], + "functionName": { + "name": "keccak256", + "nativeSrc": "4761:9:0", + "nodeType": "YulIdentifier", + "src": "4761:9:0" + }, + "nativeSrc": "4761:26:0", + "nodeType": "YulFunctionCall", + "src": "4761:26:0" + }, + "variables": [ + { + "name": "hash", + "nativeSrc": "4753:4:0", + "nodeType": "YulTypedName", + "src": "4753:4:0", + "type": "" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "challenge_mptr", + "nativeSrc": "4811:14:0", + "nodeType": "YulIdentifier", + "src": "4811:14:0" + }, + { + "arguments": [ + { + "name": "hash", + "nativeSrc": "4831:4:0", + "nodeType": "YulIdentifier", + "src": "4831:4:0" + }, + { + "name": "r", + "nativeSrc": "4837:1:0", + "nodeType": "YulIdentifier", + "src": "4837:1:0" + } + ], + "functionName": { + "name": "mod", + "nativeSrc": "4827:3:0", + "nodeType": "YulIdentifier", + "src": "4827:3:0" + }, + "nativeSrc": "4827:12:0", + "nodeType": "YulFunctionCall", + "src": "4827:12:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "4804:6:0", + "nodeType": "YulIdentifier", + "src": "4804:6:0" + }, + "nativeSrc": "4804:36:0", + "nodeType": "YulFunctionCall", + "src": "4804:36:0" + }, + "nativeSrc": "4804:36:0", + "nodeType": "YulExpressionStatement", + "src": "4804:36:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "4864:4:0", + "nodeType": "YulLiteral", + "src": "4864:4:0", + "type": "", + "value": "0x00" + }, + { + "name": "hash", + "nativeSrc": "4870:4:0", + "nodeType": "YulIdentifier", + "src": "4870:4:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "4857:6:0", + "nodeType": "YulIdentifier", + "src": "4857:6:0" + }, + "nativeSrc": "4857:18:0", + "nodeType": "YulFunctionCall", + "src": "4857:18:0" + }, + "nativeSrc": "4857:18:0", + "nodeType": "YulExpressionStatement", + "src": "4857:18:0" + }, + { + "nativeSrc": "4892:33:0", + "nodeType": "YulAssignment", + "src": "4892:33:0", + "value": { + "arguments": [ + { + "name": "challenge_mptr", + "nativeSrc": "4904:14:0", + "nodeType": "YulIdentifier", + "src": "4904:14:0" + }, + { + "kind": "number", + "nativeSrc": "4920:4:0", + "nodeType": "YulLiteral", + "src": "4920:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "4900:3:0", + "nodeType": "YulIdentifier", + "src": "4900:3:0" + }, + "nativeSrc": "4900:25:0", + "nodeType": "YulFunctionCall", + "src": "4900:25:0" + }, + "variableNames": [ + { + "name": "ret0", + "nativeSrc": "4892:4:0", + "nodeType": "YulIdentifier", + "src": "4892:4:0" + } + ] + }, + { + "nativeSrc": "4942:12:0", + "nodeType": "YulAssignment", + "src": "4942:12:0", + "value": { + "kind": "number", + "nativeSrc": "4950:4:0", + "nodeType": "YulLiteral", + "src": "4950:4:0", + "type": "", + "value": "0x20" + }, + "variableNames": [ + { + "name": "ret1", + "nativeSrc": "4942:4:0", + "nodeType": "YulIdentifier", + "src": "4942:4:0" + } + ] + } + ] + }, + "name": "squeeze_challenge", + "nativeSrc": "4660:308:0", + "nodeType": "YulFunctionDefinition", + "parameters": [ + { + "name": "challenge_mptr", + "nativeSrc": "4687:14:0", + "nodeType": "YulTypedName", + "src": "4687:14:0", + "type": "" + }, + { + "name": "hash_mptr", + "nativeSrc": "4703:9:0", + "nodeType": "YulTypedName", + "src": "4703:9:0", + "type": "" + }, + { + "name": "r", + "nativeSrc": "4714:1:0", + "nodeType": "YulTypedName", + "src": "4714:1:0", + "type": "" + } + ], + "returnVariables": [ + { + "name": "ret0", + "nativeSrc": "4720:4:0", + "nodeType": "YulTypedName", + "src": "4720:4:0", + "type": "" + }, + { + "name": "ret1", + "nativeSrc": "4726:4:0", + "nodeType": "YulTypedName", + "src": "4726:4:0", + "type": "" + } + ], + "src": "4660:308:0" + }, + { + "body": { + "nativeSrc": "5408:238:0", + "nodeType": "YulBlock", + "src": "5408:238:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "5434:4:0", + "nodeType": "YulLiteral", + "src": "5434:4:0", + "type": "", + "value": "0x20" + }, + { + "kind": "number", + "nativeSrc": "5440:4:0", + "nodeType": "YulLiteral", + "src": "5440:4:0", + "type": "", + "value": "0x01" + } + ], + "functionName": { + "name": "mstore8", + "nativeSrc": "5426:7:0", + "nodeType": "YulIdentifier", + "src": "5426:7:0" + }, + "nativeSrc": "5426:19:0", + "nodeType": "YulFunctionCall", + "src": "5426:19:0" + }, + "nativeSrc": "5426:19:0", + "nodeType": "YulExpressionStatement", + "src": "5426:19:0" + }, + { + "nativeSrc": "5462:33:0", + "nodeType": "YulVariableDeclaration", + "src": "5462:33:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "5484:4:0", + "nodeType": "YulLiteral", + "src": "5484:4:0", + "type": "", + "value": "0x00" + }, + { + "kind": "number", + "nativeSrc": "5490:4:0", + "nodeType": "YulLiteral", + "src": "5490:4:0", + "type": "", + "value": "0x21" + } + ], + "functionName": { + "name": "keccak256", + "nativeSrc": "5474:9:0", + "nodeType": "YulIdentifier", + "src": "5474:9:0" + }, + "nativeSrc": "5474:21:0", + "nodeType": "YulFunctionCall", + "src": "5474:21:0" + }, + "variables": [ + { + "name": "hash", + "nativeSrc": "5466:4:0", + "nodeType": "YulTypedName", + "src": "5466:4:0", + "type": "" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "challenge_mptr", + "nativeSrc": "5519:14:0", + "nodeType": "YulIdentifier", + "src": "5519:14:0" + }, + { + "arguments": [ + { + "name": "hash", + "nativeSrc": "5539:4:0", + "nodeType": "YulIdentifier", + "src": "5539:4:0" + }, + { + "name": "r", + "nativeSrc": "5545:1:0", + "nodeType": "YulIdentifier", + "src": "5545:1:0" + } + ], + "functionName": { + "name": "mod", + "nativeSrc": "5535:3:0", + "nodeType": "YulIdentifier", + "src": "5535:3:0" + }, + "nativeSrc": "5535:12:0", + "nodeType": "YulFunctionCall", + "src": "5535:12:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "5512:6:0", + "nodeType": "YulIdentifier", + "src": "5512:6:0" + }, + "nativeSrc": "5512:36:0", + "nodeType": "YulFunctionCall", + "src": "5512:36:0" + }, + "nativeSrc": "5512:36:0", + "nodeType": "YulExpressionStatement", + "src": "5512:36:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "5572:4:0", + "nodeType": "YulLiteral", + "src": "5572:4:0", + "type": "", + "value": "0x00" + }, + { + "name": "hash", + "nativeSrc": "5578:4:0", + "nodeType": "YulIdentifier", + "src": "5578:4:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "5565:6:0", + "nodeType": "YulIdentifier", + "src": "5565:6:0" + }, + "nativeSrc": "5565:18:0", + "nodeType": "YulFunctionCall", + "src": "5565:18:0" + }, + "nativeSrc": "5565:18:0", + "nodeType": "YulExpressionStatement", + "src": "5565:18:0" + }, + { + "nativeSrc": "5600:32:0", + "nodeType": "YulAssignment", + "src": "5600:32:0", + "value": { + "arguments": [ + { + "name": "challenge_mptr", + "nativeSrc": "5611:14:0", + "nodeType": "YulIdentifier", + "src": "5611:14:0" + }, + { + "kind": "number", + "nativeSrc": "5627:4:0", + "nodeType": "YulLiteral", + "src": "5627:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "5607:3:0", + "nodeType": "YulIdentifier", + "src": "5607:3:0" + }, + "nativeSrc": "5607:25:0", + "nodeType": "YulFunctionCall", + "src": "5607:25:0" + }, + "variableNames": [ + { + "name": "ret", + "nativeSrc": "5600:3:0", + "nodeType": "YulIdentifier", + "src": "5600:3:0" + } + ] + } + ] + }, + "name": "squeeze_challenge_cont", + "nativeSrc": "5350:296:0", + "nodeType": "YulFunctionDefinition", + "parameters": [ + { + "name": "challenge_mptr", + "nativeSrc": "5382:14:0", + "nodeType": "YulTypedName", + "src": "5382:14:0", + "type": "" + }, + { + "name": "r", + "nativeSrc": "5398:1:0", + "nodeType": "YulTypedName", + "src": "5398:1:0", + "type": "" + } + ], + "returnVariables": [ + { + "name": "ret", + "nativeSrc": "5404:3:0", + "nodeType": "YulTypedName", + "src": "5404:3:0", + "type": "" + } + ], + "src": "5350:296:0" + }, + { + "body": { + "nativeSrc": "5841:1750:0", + "nodeType": "YulBlock", + "src": "5841:1750:0", + "statements": [ + { + "nativeSrc": "5859:23:0", + "nodeType": "YulVariableDeclaration", + "src": "5859:23:0", + "value": { + "name": "mptr_end", + "nativeSrc": "5874:8:0", + "nodeType": "YulIdentifier", + "src": "5874:8:0" + }, + "variables": [ + { + "name": "gp_mptr", + "nativeSrc": "5863:7:0", + "nodeType": "YulTypedName", + "src": "5863:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "5899:27:0", + "nodeType": "YulVariableDeclaration", + "src": "5899:27:0", + "value": { + "arguments": [ + { + "name": "mptr_start", + "nativeSrc": "5915:10:0", + "nodeType": "YulIdentifier", + "src": "5915:10:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "5909:5:0", + "nodeType": "YulIdentifier", + "src": "5909:5:0" + }, + "nativeSrc": "5909:17:0", + "nodeType": "YulFunctionCall", + "src": "5909:17:0" + }, + "variables": [ + { + "name": "gp", + "nativeSrc": "5903:2:0", + "nodeType": "YulTypedName", + "src": "5903:2:0", + "type": "" + } + ] + }, + { + "nativeSrc": "5943:33:0", + "nodeType": "YulVariableDeclaration", + "src": "5943:33:0", + "value": { + "arguments": [ + { + "name": "mptr_start", + "nativeSrc": "5959:10:0", + "nodeType": "YulIdentifier", + "src": "5959:10:0" + }, + { + "kind": "number", + "nativeSrc": "5971:4:0", + "nodeType": "YulLiteral", + "src": "5971:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "5955:3:0", + "nodeType": "YulIdentifier", + "src": "5955:3:0" + }, + "nativeSrc": "5955:21:0", + "nodeType": "YulFunctionCall", + "src": "5955:21:0" + }, + "variables": [ + { + "name": "mptr", + "nativeSrc": "5947:4:0", + "nodeType": "YulTypedName", + "src": "5947:4:0", + "type": "" + } + ] + }, + { + "body": { + "nativeSrc": "6109:206:0", + "nodeType": "YulBlock", + "src": "6109:206:0", + "statements": [ + { + "nativeSrc": "6131:32:0", + "nodeType": "YulAssignment", + "src": "6131:32:0", + "value": { + "arguments": [ + { + "name": "gp", + "nativeSrc": "6144:2:0", + "nodeType": "YulIdentifier", + "src": "6144:2:0" + }, + { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "6154:4:0", + "nodeType": "YulIdentifier", + "src": "6154:4:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "6148:5:0", + "nodeType": "YulIdentifier", + "src": "6148:5:0" + }, + "nativeSrc": "6148:11:0", + "nodeType": "YulFunctionCall", + "src": "6148:11:0" + }, + { + "name": "r", + "nativeSrc": "6161:1:0", + "nodeType": "YulIdentifier", + "src": "6161:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "6137:6:0", + "nodeType": "YulIdentifier", + "src": "6137:6:0" + }, + "nativeSrc": "6137:26:0", + "nodeType": "YulFunctionCall", + "src": "6137:26:0" + }, + "variableNames": [ + { + "name": "gp", + "nativeSrc": "6131:2:0", + "nodeType": "YulIdentifier", + "src": "6131:2:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "gp_mptr", + "nativeSrc": "6191:7:0", + "nodeType": "YulIdentifier", + "src": "6191:7:0" + }, + { + "name": "gp", + "nativeSrc": "6200:2:0", + "nodeType": "YulIdentifier", + "src": "6200:2:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "6184:6:0", + "nodeType": "YulIdentifier", + "src": "6184:6:0" + }, + "nativeSrc": "6184:19:0", + "nodeType": "YulFunctionCall", + "src": "6184:19:0" + }, + "nativeSrc": "6184:19:0", + "nodeType": "YulExpressionStatement", + "src": "6184:19:0" + }, + { + "nativeSrc": "6224:23:0", + "nodeType": "YulAssignment", + "src": "6224:23:0", + "value": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "6236:4:0", + "nodeType": "YulIdentifier", + "src": "6236:4:0" + }, + { + "kind": "number", + "nativeSrc": "6242:4:0", + "nodeType": "YulLiteral", + "src": "6242:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "6232:3:0", + "nodeType": "YulIdentifier", + "src": "6232:3:0" + }, + "nativeSrc": "6232:15:0", + "nodeType": "YulFunctionCall", + "src": "6232:15:0" + }, + "variableNames": [ + { + "name": "mptr", + "nativeSrc": "6224:4:0", + "nodeType": "YulIdentifier", + "src": "6224:4:0" + } + ] + }, + { + "nativeSrc": "6268:29:0", + "nodeType": "YulAssignment", + "src": "6268:29:0", + "value": { + "arguments": [ + { + "name": "gp_mptr", + "nativeSrc": "6283:7:0", + "nodeType": "YulIdentifier", + "src": "6283:7:0" + }, + { + "kind": "number", + "nativeSrc": "6292:4:0", + "nodeType": "YulLiteral", + "src": "6292:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "6279:3:0", + "nodeType": "YulIdentifier", + "src": "6279:3:0" + }, + "nativeSrc": "6279:18:0", + "nodeType": "YulFunctionCall", + "src": "6279:18:0" + }, + "variableNames": [ + { + "name": "gp_mptr", + "nativeSrc": "6268:7:0", + "nodeType": "YulIdentifier", + "src": "6268:7:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "6043:4:0", + "nodeType": "YulIdentifier", + "src": "6043:4:0" + }, + { + "arguments": [ + { + "name": "mptr_end", + "nativeSrc": "6053:8:0", + "nodeType": "YulIdentifier", + "src": "6053:8:0" + }, + { + "kind": "number", + "nativeSrc": "6063:4:0", + "nodeType": "YulLiteral", + "src": "6063:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "6049:3:0", + "nodeType": "YulIdentifier", + "src": "6049:3:0" + }, + "nativeSrc": "6049:19:0", + "nodeType": "YulFunctionCall", + "src": "6049:19:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "6040:2:0", + "nodeType": "YulIdentifier", + "src": "6040:2:0" + }, + "nativeSrc": "6040:29:0", + "nodeType": "YulFunctionCall", + "src": "6040:29:0" + }, + "nativeSrc": "5993:322:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "6090:2:0", + "nodeType": "YulBlock", + "src": "6090:2:0", + "statements": [] + }, + "pre": { + "nativeSrc": "6017:2:0", + "nodeType": "YulBlock", + "src": "6017:2:0", + "statements": [] + }, + "src": "5993:322:0" + }, + { + "nativeSrc": "6332:32:0", + "nodeType": "YulAssignment", + "src": "6332:32:0", + "value": { + "arguments": [ + { + "name": "gp", + "nativeSrc": "6345:2:0", + "nodeType": "YulIdentifier", + "src": "6345:2:0" + }, + { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "6355:4:0", + "nodeType": "YulIdentifier", + "src": "6355:4:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "6349:5:0", + "nodeType": "YulIdentifier", + "src": "6349:5:0" + }, + "nativeSrc": "6349:11:0", + "nodeType": "YulFunctionCall", + "src": "6349:11:0" + }, + { + "name": "r", + "nativeSrc": "6362:1:0", + "nodeType": "YulIdentifier", + "src": "6362:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "6338:6:0", + "nodeType": "YulIdentifier", + "src": "6338:6:0" + }, + "nativeSrc": "6338:26:0", + "nodeType": "YulFunctionCall", + "src": "6338:26:0" + }, + "variableNames": [ + { + "name": "gp", + "nativeSrc": "6332:2:0", + "nodeType": "YulIdentifier", + "src": "6332:2:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "gp_mptr", + "nativeSrc": "6389:7:0", + "nodeType": "YulIdentifier", + "src": "6389:7:0" + }, + { + "kind": "number", + "nativeSrc": "6398:4:0", + "nodeType": "YulLiteral", + "src": "6398:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "6382:6:0", + "nodeType": "YulIdentifier", + "src": "6382:6:0" + }, + "nativeSrc": "6382:21:0", + "nodeType": "YulFunctionCall", + "src": "6382:21:0" + }, + "nativeSrc": "6382:21:0", + "nodeType": "YulExpressionStatement", + "src": "6382:21:0" + }, + { + "expression": { + "arguments": [ + { + "arguments": [ + { + "name": "gp_mptr", + "nativeSrc": "6431:7:0", + "nodeType": "YulIdentifier", + "src": "6431:7:0" + }, + { + "kind": "number", + "nativeSrc": "6440:4:0", + "nodeType": "YulLiteral", + "src": "6440:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "6427:3:0", + "nodeType": "YulIdentifier", + "src": "6427:3:0" + }, + "nativeSrc": "6427:18:0", + "nodeType": "YulFunctionCall", + "src": "6427:18:0" + }, + { + "kind": "number", + "nativeSrc": "6447:4:0", + "nodeType": "YulLiteral", + "src": "6447:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "6420:6:0", + "nodeType": "YulIdentifier", + "src": "6420:6:0" + }, + "nativeSrc": "6420:32:0", + "nodeType": "YulFunctionCall", + "src": "6420:32:0" + }, + "nativeSrc": "6420:32:0", + "nodeType": "YulExpressionStatement", + "src": "6420:32:0" + }, + { + "expression": { + "arguments": [ + { + "arguments": [ + { + "name": "gp_mptr", + "nativeSrc": "6480:7:0", + "nodeType": "YulIdentifier", + "src": "6480:7:0" + }, + { + "kind": "number", + "nativeSrc": "6489:4:0", + "nodeType": "YulLiteral", + "src": "6489:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "6476:3:0", + "nodeType": "YulIdentifier", + "src": "6476:3:0" + }, + "nativeSrc": "6476:18:0", + "nodeType": "YulFunctionCall", + "src": "6476:18:0" + }, + { + "kind": "number", + "nativeSrc": "6496:4:0", + "nodeType": "YulLiteral", + "src": "6496:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "6469:6:0", + "nodeType": "YulIdentifier", + "src": "6469:6:0" + }, + "nativeSrc": "6469:32:0", + "nodeType": "YulFunctionCall", + "src": "6469:32:0" + }, + "nativeSrc": "6469:32:0", + "nodeType": "YulExpressionStatement", + "src": "6469:32:0" + }, + { + "expression": { + "arguments": [ + { + "arguments": [ + { + "name": "gp_mptr", + "nativeSrc": "6529:7:0", + "nodeType": "YulIdentifier", + "src": "6529:7:0" + }, + { + "kind": "number", + "nativeSrc": "6538:4:0", + "nodeType": "YulLiteral", + "src": "6538:4:0", + "type": "", + "value": "0x60" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "6525:3:0", + "nodeType": "YulIdentifier", + "src": "6525:3:0" + }, + "nativeSrc": "6525:18:0", + "nodeType": "YulFunctionCall", + "src": "6525:18:0" + }, + { + "name": "gp", + "nativeSrc": "6545:2:0", + "nodeType": "YulIdentifier", + "src": "6545:2:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "6518:6:0", + "nodeType": "YulIdentifier", + "src": "6518:6:0" + }, + "nativeSrc": "6518:30:0", + "nodeType": "YulFunctionCall", + "src": "6518:30:0" + }, + "nativeSrc": "6518:30:0", + "nodeType": "YulExpressionStatement", + "src": "6518:30:0" + }, + { + "expression": { + "arguments": [ + { + "arguments": [ + { + "name": "gp_mptr", + "nativeSrc": "6576:7:0", + "nodeType": "YulIdentifier", + "src": "6576:7:0" + }, + { + "kind": "number", + "nativeSrc": "6585:4:0", + "nodeType": "YulLiteral", + "src": "6585:4:0", + "type": "", + "value": "0x80" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "6572:3:0", + "nodeType": "YulIdentifier", + "src": "6572:3:0" + }, + "nativeSrc": "6572:18:0", + "nodeType": "YulFunctionCall", + "src": "6572:18:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "6596:1:0", + "nodeType": "YulIdentifier", + "src": "6596:1:0" + }, + { + "kind": "number", + "nativeSrc": "6599:1:0", + "nodeType": "YulLiteral", + "src": "6599:1:0", + "type": "", + "value": "2" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "6592:3:0", + "nodeType": "YulIdentifier", + "src": "6592:3:0" + }, + "nativeSrc": "6592:9:0", + "nodeType": "YulFunctionCall", + "src": "6592:9:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "6565:6:0", + "nodeType": "YulIdentifier", + "src": "6565:6:0" + }, + "nativeSrc": "6565:37:0", + "nodeType": "YulFunctionCall", + "src": "6565:37:0" + }, + "nativeSrc": "6565:37:0", + "nodeType": "YulExpressionStatement", + "src": "6565:37:0" + }, + { + "expression": { + "arguments": [ + { + "arguments": [ + { + "name": "gp_mptr", + "nativeSrc": "6630:7:0", + "nodeType": "YulIdentifier", + "src": "6630:7:0" + }, + { + "kind": "number", + "nativeSrc": "6639:4:0", + "nodeType": "YulLiteral", + "src": "6639:4:0", + "type": "", + "value": "0xa0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "6626:3:0", + "nodeType": "YulIdentifier", + "src": "6626:3:0" + }, + "nativeSrc": "6626:18:0", + "nodeType": "YulFunctionCall", + "src": "6626:18:0" + }, + { + "name": "r", + "nativeSrc": "6646:1:0", + "nodeType": "YulIdentifier", + "src": "6646:1:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "6619:6:0", + "nodeType": "YulIdentifier", + "src": "6619:6:0" + }, + "nativeSrc": "6619:29:0", + "nodeType": "YulFunctionCall", + "src": "6619:29:0" + }, + "nativeSrc": "6619:29:0", + "nodeType": "YulExpressionStatement", + "src": "6619:29:0" + }, + { + "nativeSrc": "6665:74:0", + "nodeType": "YulAssignment", + "src": "6665:74:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "6676:7:0", + "nodeType": "YulIdentifier", + "src": "6676:7:0" + }, + { + "arguments": [ + { + "arguments": [], + "functionName": { + "name": "gas", + "nativeSrc": "6696:3:0", + "nodeType": "YulIdentifier", + "src": "6696:3:0" + }, + "nativeSrc": "6696:5:0", + "nodeType": "YulFunctionCall", + "src": "6696:5:0" + }, + { + "kind": "number", + "nativeSrc": "6703:4:0", + "nodeType": "YulLiteral", + "src": "6703:4:0", + "type": "", + "value": "0x05" + }, + { + "name": "gp_mptr", + "nativeSrc": "6709:7:0", + "nodeType": "YulIdentifier", + "src": "6709:7:0" + }, + { + "kind": "number", + "nativeSrc": "6718:4:0", + "nodeType": "YulLiteral", + "src": "6718:4:0", + "type": "", + "value": "0xc0" + }, + { + "name": "gp_mptr", + "nativeSrc": "6724:7:0", + "nodeType": "YulIdentifier", + "src": "6724:7:0" + }, + { + "kind": "number", + "nativeSrc": "6733:4:0", + "nodeType": "YulLiteral", + "src": "6733:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "staticcall", + "nativeSrc": "6685:10:0", + "nodeType": "YulIdentifier", + "src": "6685:10:0" + }, + "nativeSrc": "6685:53:0", + "nodeType": "YulFunctionCall", + "src": "6685:53:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "6672:3:0", + "nodeType": "YulIdentifier", + "src": "6672:3:0" + }, + "nativeSrc": "6672:67:0", + "nodeType": "YulFunctionCall", + "src": "6672:67:0" + }, + "variableNames": [ + { + "name": "ret", + "nativeSrc": "6665:3:0", + "nodeType": "YulIdentifier", + "src": "6665:3:0" + } + ] + }, + { + "nativeSrc": "6756:29:0", + "nodeType": "YulVariableDeclaration", + "src": "6756:29:0", + "value": { + "arguments": [ + { + "name": "gp_mptr", + "nativeSrc": "6777:7:0", + "nodeType": "YulIdentifier", + "src": "6777:7:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "6771:5:0", + "nodeType": "YulIdentifier", + "src": "6771:5:0" + }, + "nativeSrc": "6771:14:0", + "nodeType": "YulFunctionCall", + "src": "6771:14:0" + }, + "variables": [ + { + "name": "all_inv", + "nativeSrc": "6760:7:0", + "nodeType": "YulTypedName", + "src": "6760:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "6803:28:0", + "nodeType": "YulVariableDeclaration", + "src": "6803:28:0", + "value": { + "name": "mptr_start", + "nativeSrc": "6821:10:0", + "nodeType": "YulIdentifier", + "src": "6821:10:0" + }, + "variables": [ + { + "name": "first_mptr", + "nativeSrc": "6807:10:0", + "nodeType": "YulTypedName", + "src": "6807:10:0", + "type": "" + } + ] + }, + { + "nativeSrc": "6848:40:0", + "nodeType": "YulVariableDeclaration", + "src": "6848:40:0", + "value": { + "arguments": [ + { + "name": "first_mptr", + "nativeSrc": "6871:10:0", + "nodeType": "YulIdentifier", + "src": "6871:10:0" + }, + { + "kind": "number", + "nativeSrc": "6883:4:0", + "nodeType": "YulLiteral", + "src": "6883:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "6867:3:0", + "nodeType": "YulIdentifier", + "src": "6867:3:0" + }, + "nativeSrc": "6867:21:0", + "nodeType": "YulFunctionCall", + "src": "6867:21:0" + }, + "variables": [ + { + "name": "second_mptr", + "nativeSrc": "6852:11:0", + "nodeType": "YulTypedName", + "src": "6852:11:0", + "type": "" + } + ] + }, + { + "nativeSrc": "6905:29:0", + "nodeType": "YulAssignment", + "src": "6905:29:0", + "value": { + "arguments": [ + { + "name": "gp_mptr", + "nativeSrc": "6920:7:0", + "nodeType": "YulIdentifier", + "src": "6920:7:0" + }, + { + "kind": "number", + "nativeSrc": "6929:4:0", + "nodeType": "YulLiteral", + "src": "6929:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "6916:3:0", + "nodeType": "YulIdentifier", + "src": "6916:3:0" + }, + "nativeSrc": "6916:18:0", + "nodeType": "YulFunctionCall", + "src": "6916:18:0" + }, + "variableNames": [ + { + "name": "gp_mptr", + "nativeSrc": "6905:7:0", + "nodeType": "YulIdentifier", + "src": "6905:7:0" + } + ] + }, + { + "body": { + "nativeSrc": "7059:280:0", + "nodeType": "YulBlock", + "src": "7059:280:0", + "statements": [ + { + "nativeSrc": "7081:45:0", + "nodeType": "YulVariableDeclaration", + "src": "7081:45:0", + "value": { + "arguments": [ + { + "name": "all_inv", + "nativeSrc": "7099:7:0", + "nodeType": "YulIdentifier", + "src": "7099:7:0" + }, + { + "arguments": [ + { + "name": "gp_mptr", + "nativeSrc": "7114:7:0", + "nodeType": "YulIdentifier", + "src": "7114:7:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "7108:5:0", + "nodeType": "YulIdentifier", + "src": "7108:5:0" + }, + "nativeSrc": "7108:14:0", + "nodeType": "YulFunctionCall", + "src": "7108:14:0" + }, + { + "name": "r", + "nativeSrc": "7124:1:0", + "nodeType": "YulIdentifier", + "src": "7124:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "7092:6:0", + "nodeType": "YulIdentifier", + "src": "7092:6:0" + }, + "nativeSrc": "7092:34:0", + "nodeType": "YulFunctionCall", + "src": "7092:34:0" + }, + "variables": [ + { + "name": "inv", + "nativeSrc": "7085:3:0", + "nodeType": "YulTypedName", + "src": "7085:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "7147:42:0", + "nodeType": "YulAssignment", + "src": "7147:42:0", + "value": { + "arguments": [ + { + "name": "all_inv", + "nativeSrc": "7165:7:0", + "nodeType": "YulIdentifier", + "src": "7165:7:0" + }, + { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "7180:4:0", + "nodeType": "YulIdentifier", + "src": "7180:4:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "7174:5:0", + "nodeType": "YulIdentifier", + "src": "7174:5:0" + }, + "nativeSrc": "7174:11:0", + "nodeType": "YulFunctionCall", + "src": "7174:11:0" + }, + { + "name": "r", + "nativeSrc": "7187:1:0", + "nodeType": "YulIdentifier", + "src": "7187:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "7158:6:0", + "nodeType": "YulIdentifier", + "src": "7158:6:0" + }, + "nativeSrc": "7158:31:0", + "nodeType": "YulFunctionCall", + "src": "7158:31:0" + }, + "variableNames": [ + { + "name": "all_inv", + "nativeSrc": "7147:7:0", + "nodeType": "YulIdentifier", + "src": "7147:7:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "7217:4:0", + "nodeType": "YulIdentifier", + "src": "7217:4:0" + }, + { + "name": "inv", + "nativeSrc": "7223:3:0", + "nodeType": "YulIdentifier", + "src": "7223:3:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "7210:6:0", + "nodeType": "YulIdentifier", + "src": "7210:6:0" + }, + "nativeSrc": "7210:17:0", + "nodeType": "YulFunctionCall", + "src": "7210:17:0" + }, + "nativeSrc": "7210:17:0", + "nodeType": "YulExpressionStatement", + "src": "7210:17:0" + }, + { + "nativeSrc": "7248:23:0", + "nodeType": "YulAssignment", + "src": "7248:23:0", + "value": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "7260:4:0", + "nodeType": "YulIdentifier", + "src": "7260:4:0" + }, + { + "kind": "number", + "nativeSrc": "7266:4:0", + "nodeType": "YulLiteral", + "src": "7266:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "7256:3:0", + "nodeType": "YulIdentifier", + "src": "7256:3:0" + }, + "nativeSrc": "7256:15:0", + "nodeType": "YulFunctionCall", + "src": "7256:15:0" + }, + "variableNames": [ + { + "name": "mptr", + "nativeSrc": "7248:4:0", + "nodeType": "YulIdentifier", + "src": "7248:4:0" + } + ] + }, + { + "nativeSrc": "7292:29:0", + "nodeType": "YulAssignment", + "src": "7292:29:0", + "value": { + "arguments": [ + { + "name": "gp_mptr", + "nativeSrc": "7307:7:0", + "nodeType": "YulIdentifier", + "src": "7307:7:0" + }, + { + "kind": "number", + "nativeSrc": "7316:4:0", + "nodeType": "YulLiteral", + "src": "7316:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "7303:3:0", + "nodeType": "YulIdentifier", + "src": "7303:3:0" + }, + "nativeSrc": "7303:18:0", + "nodeType": "YulFunctionCall", + "src": "7303:18:0" + }, + "variableNames": [ + { + "name": "gp_mptr", + "nativeSrc": "7292:7:0", + "nodeType": "YulIdentifier", + "src": "7292:7:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "second_mptr", + "nativeSrc": "7001:11:0", + "nodeType": "YulIdentifier", + "src": "7001:11:0" + }, + { + "name": "mptr", + "nativeSrc": "7014:4:0", + "nodeType": "YulIdentifier", + "src": "7014:4:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "6998:2:0", + "nodeType": "YulIdentifier", + "src": "6998:2:0" + }, + "nativeSrc": "6998:21:0", + "nodeType": "YulFunctionCall", + "src": "6998:21:0" + }, + "nativeSrc": "6951:388:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "7040:2:0", + "nodeType": "YulBlock", + "src": "7040:2:0", + "statements": [] + }, + "pre": { + "nativeSrc": "6975:2:0", + "nodeType": "YulBlock", + "src": "6975:2:0", + "statements": [] + }, + "src": "6951:388:0" + }, + { + "nativeSrc": "7356:55:0", + "nodeType": "YulVariableDeclaration", + "src": "7356:55:0", + "value": { + "arguments": [ + { + "name": "all_inv", + "nativeSrc": "7380:7:0", + "nodeType": "YulIdentifier", + "src": "7380:7:0" + }, + { + "arguments": [ + { + "name": "second_mptr", + "nativeSrc": "7395:11:0", + "nodeType": "YulIdentifier", + "src": "7395:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "7389:5:0", + "nodeType": "YulIdentifier", + "src": "7389:5:0" + }, + "nativeSrc": "7389:18:0", + "nodeType": "YulFunctionCall", + "src": "7389:18:0" + }, + { + "name": "r", + "nativeSrc": "7409:1:0", + "nodeType": "YulIdentifier", + "src": "7409:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "7373:6:0", + "nodeType": "YulIdentifier", + "src": "7373:6:0" + }, + "nativeSrc": "7373:38:0", + "nodeType": "YulFunctionCall", + "src": "7373:38:0" + }, + "variables": [ + { + "name": "inv_first", + "nativeSrc": "7360:9:0", + "nodeType": "YulTypedName", + "src": "7360:9:0", + "type": "" + } + ] + }, + { + "nativeSrc": "7428:55:0", + "nodeType": "YulVariableDeclaration", + "src": "7428:55:0", + "value": { + "arguments": [ + { + "name": "all_inv", + "nativeSrc": "7453:7:0", + "nodeType": "YulIdentifier", + "src": "7453:7:0" + }, + { + "arguments": [ + { + "name": "first_mptr", + "nativeSrc": "7468:10:0", + "nodeType": "YulIdentifier", + "src": "7468:10:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "7462:5:0", + "nodeType": "YulIdentifier", + "src": "7462:5:0" + }, + "nativeSrc": "7462:17:0", + "nodeType": "YulFunctionCall", + "src": "7462:17:0" + }, + { + "name": "r", + "nativeSrc": "7481:1:0", + "nodeType": "YulIdentifier", + "src": "7481:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "7446:6:0", + "nodeType": "YulIdentifier", + "src": "7446:6:0" + }, + "nativeSrc": "7446:37:0", + "nodeType": "YulFunctionCall", + "src": "7446:37:0" + }, + "variables": [ + { + "name": "inv_second", + "nativeSrc": "7432:10:0", + "nodeType": "YulTypedName", + "src": "7432:10:0", + "type": "" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "first_mptr", + "nativeSrc": "7507:10:0", + "nodeType": "YulIdentifier", + "src": "7507:10:0" + }, + { + "name": "inv_first", + "nativeSrc": "7519:9:0", + "nodeType": "YulIdentifier", + "src": "7519:9:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "7500:6:0", + "nodeType": "YulIdentifier", + "src": "7500:6:0" + }, + "nativeSrc": "7500:29:0", + "nodeType": "YulFunctionCall", + "src": "7500:29:0" + }, + "nativeSrc": "7500:29:0", + "nodeType": "YulExpressionStatement", + "src": "7500:29:0" + }, + { + "expression": { + "arguments": [ + { + "name": "second_mptr", + "nativeSrc": "7553:11:0", + "nodeType": "YulIdentifier", + "src": "7553:11:0" + }, + { + "name": "inv_second", + "nativeSrc": "7566:10:0", + "nodeType": "YulIdentifier", + "src": "7566:10:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "7546:6:0", + "nodeType": "YulIdentifier", + "src": "7546:6:0" + }, + "nativeSrc": "7546:31:0", + "nodeType": "YulFunctionCall", + "src": "7546:31:0" + }, + "nativeSrc": "7546:31:0", + "nodeType": "YulExpressionStatement", + "src": "7546:31:0" + } + ] + }, + "name": "batch_invert", + "nativeSrc": "5778:1813:0", + "nodeType": "YulFunctionDefinition", + "parameters": [ + { + "name": "success", + "nativeSrc": "5800:7:0", + "nodeType": "YulTypedName", + "src": "5800:7:0", + "type": "" + }, + { + "name": "mptr_start", + "nativeSrc": "5809:10:0", + "nodeType": "YulTypedName", + "src": "5809:10:0", + "type": "" + }, + { + "name": "mptr_end", + "nativeSrc": "5821:8:0", + "nodeType": "YulTypedName", + "src": "5821:8:0", + "type": "" + }, + { + "name": "r", + "nativeSrc": "5831:1:0", + "nodeType": "YulTypedName", + "src": "5831:1:0", + "type": "" + } + ], + "returnVariables": [ + { + "name": "ret", + "nativeSrc": "5837:3:0", + "nodeType": "YulTypedName", + "src": "5837:3:0", + "type": "" + } + ], + "src": "5778:1813:0" + }, + { + "body": { + "nativeSrc": "7742:164:0", + "nodeType": "YulBlock", + "src": "7742:164:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "7767:4:0", + "nodeType": "YulLiteral", + "src": "7767:4:0", + "type": "", + "value": "0x40" + }, + { + "name": "x", + "nativeSrc": "7773:1:0", + "nodeType": "YulIdentifier", + "src": "7773:1:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "7760:6:0", + "nodeType": "YulIdentifier", + "src": "7760:6:0" + }, + "nativeSrc": "7760:15:0", + "nodeType": "YulFunctionCall", + "src": "7760:15:0" + }, + "nativeSrc": "7760:15:0", + "nodeType": "YulExpressionStatement", + "src": "7760:15:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "7799:4:0", + "nodeType": "YulLiteral", + "src": "7799:4:0", + "type": "", + "value": "0x60" + }, + { + "name": "y", + "nativeSrc": "7805:1:0", + "nodeType": "YulIdentifier", + "src": "7805:1:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "7792:6:0", + "nodeType": "YulIdentifier", + "src": "7792:6:0" + }, + "nativeSrc": "7792:15:0", + "nodeType": "YulFunctionCall", + "src": "7792:15:0" + }, + "nativeSrc": "7792:15:0", + "nodeType": "YulExpressionStatement", + "src": "7792:15:0" + }, + { + "nativeSrc": "7824:68:0", + "nodeType": "YulAssignment", + "src": "7824:68:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "7835:7:0", + "nodeType": "YulIdentifier", + "src": "7835:7:0" + }, + { + "arguments": [ + { + "arguments": [], + "functionName": { + "name": "gas", + "nativeSrc": "7855:3:0", + "nodeType": "YulIdentifier", + "src": "7855:3:0" + }, + "nativeSrc": "7855:5:0", + "nodeType": "YulFunctionCall", + "src": "7855:5:0" + }, + { + "kind": "number", + "nativeSrc": "7862:4:0", + "nodeType": "YulLiteral", + "src": "7862:4:0", + "type": "", + "value": "0x06" + }, + { + "kind": "number", + "nativeSrc": "7868:4:0", + "nodeType": "YulLiteral", + "src": "7868:4:0", + "type": "", + "value": "0x00" + }, + { + "kind": "number", + "nativeSrc": "7874:4:0", + "nodeType": "YulLiteral", + "src": "7874:4:0", + "type": "", + "value": "0x80" + }, + { + "kind": "number", + "nativeSrc": "7880:4:0", + "nodeType": "YulLiteral", + "src": "7880:4:0", + "type": "", + "value": "0x00" + }, + { + "kind": "number", + "nativeSrc": "7886:4:0", + "nodeType": "YulLiteral", + "src": "7886:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "staticcall", + "nativeSrc": "7844:10:0", + "nodeType": "YulIdentifier", + "src": "7844:10:0" + }, + "nativeSrc": "7844:47:0", + "nodeType": "YulFunctionCall", + "src": "7844:47:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "7831:3:0", + "nodeType": "YulIdentifier", + "src": "7831:3:0" + }, + "nativeSrc": "7831:61:0", + "nodeType": "YulFunctionCall", + "src": "7831:61:0" + }, + "variableNames": [ + { + "name": "ret", + "nativeSrc": "7824:3:0", + "nodeType": "YulIdentifier", + "src": "7824:3:0" + } + ] + } + ] + }, + "name": "ec_add_acc", + "nativeSrc": "7700:206:0", + "nodeType": "YulFunctionDefinition", + "parameters": [ + { + "name": "success", + "nativeSrc": "7720:7:0", + "nodeType": "YulTypedName", + "src": "7720:7:0", + "type": "" + }, + { + "name": "x", + "nativeSrc": "7729:1:0", + "nodeType": "YulTypedName", + "src": "7729:1:0", + "type": "" + }, + { + "name": "y", + "nativeSrc": "7732:1:0", + "nodeType": "YulTypedName", + "src": "7732:1:0", + "type": "" + } + ], + "returnVariables": [ + { + "name": "ret", + "nativeSrc": "7738:3:0", + "nodeType": "YulTypedName", + "src": "7738:3:0", + "type": "" + } + ], + "src": "7700:206:0" + }, + { + "body": { + "nativeSrc": "8018:137:0", + "nodeType": "YulBlock", + "src": "8018:137:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "8043:4:0", + "nodeType": "YulLiteral", + "src": "8043:4:0", + "type": "", + "value": "0x40" + }, + { + "name": "scalar", + "nativeSrc": "8049:6:0", + "nodeType": "YulIdentifier", + "src": "8049:6:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "8036:6:0", + "nodeType": "YulIdentifier", + "src": "8036:6:0" + }, + "nativeSrc": "8036:20:0", + "nodeType": "YulFunctionCall", + "src": "8036:20:0" + }, + "nativeSrc": "8036:20:0", + "nodeType": "YulExpressionStatement", + "src": "8036:20:0" + }, + { + "nativeSrc": "8073:68:0", + "nodeType": "YulAssignment", + "src": "8073:68:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "8084:7:0", + "nodeType": "YulIdentifier", + "src": "8084:7:0" + }, + { + "arguments": [ + { + "arguments": [], + "functionName": { + "name": "gas", + "nativeSrc": "8104:3:0", + "nodeType": "YulIdentifier", + "src": "8104:3:0" + }, + "nativeSrc": "8104:5:0", + "nodeType": "YulFunctionCall", + "src": "8104:5:0" + }, + { + "kind": "number", + "nativeSrc": "8111:4:0", + "nodeType": "YulLiteral", + "src": "8111:4:0", + "type": "", + "value": "0x07" + }, + { + "kind": "number", + "nativeSrc": "8117:4:0", + "nodeType": "YulLiteral", + "src": "8117:4:0", + "type": "", + "value": "0x00" + }, + { + "kind": "number", + "nativeSrc": "8123:4:0", + "nodeType": "YulLiteral", + "src": "8123:4:0", + "type": "", + "value": "0x60" + }, + { + "kind": "number", + "nativeSrc": "8129:4:0", + "nodeType": "YulLiteral", + "src": "8129:4:0", + "type": "", + "value": "0x00" + }, + { + "kind": "number", + "nativeSrc": "8135:4:0", + "nodeType": "YulLiteral", + "src": "8135:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "staticcall", + "nativeSrc": "8093:10:0", + "nodeType": "YulIdentifier", + "src": "8093:10:0" + }, + "nativeSrc": "8093:47:0", + "nodeType": "YulFunctionCall", + "src": "8093:47:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "8080:3:0", + "nodeType": "YulIdentifier", + "src": "8080:3:0" + }, + "nativeSrc": "8080:61:0", + "nodeType": "YulFunctionCall", + "src": "8080:61:0" + }, + "variableNames": [ + { + "name": "ret", + "nativeSrc": "8073:3:0", + "nodeType": "YulIdentifier", + "src": "8073:3:0" + } + ] + } + ] + }, + "name": "ec_mul_acc", + "nativeSrc": "7974:181:0", + "nodeType": "YulFunctionDefinition", + "parameters": [ + { + "name": "success", + "nativeSrc": "7994:7:0", + "nodeType": "YulTypedName", + "src": "7994:7:0", + "type": "" + }, + { + "name": "scalar", + "nativeSrc": "8003:6:0", + "nodeType": "YulTypedName", + "src": "8003:6:0", + "type": "" + } + ], + "returnVariables": [ + { + "name": "ret", + "nativeSrc": "8014:3:0", + "nodeType": "YulTypedName", + "src": "8014:3:0", + "type": "" + } + ], + "src": "7974:181:0" + }, + { + "body": { + "nativeSrc": "8306:164:0", + "nodeType": "YulBlock", + "src": "8306:164:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "8331:4:0", + "nodeType": "YulLiteral", + "src": "8331:4:0", + "type": "", + "value": "0xc0" + }, + { + "name": "x", + "nativeSrc": "8337:1:0", + "nodeType": "YulIdentifier", + "src": "8337:1:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "8324:6:0", + "nodeType": "YulIdentifier", + "src": "8324:6:0" + }, + "nativeSrc": "8324:15:0", + "nodeType": "YulFunctionCall", + "src": "8324:15:0" + }, + "nativeSrc": "8324:15:0", + "nodeType": "YulExpressionStatement", + "src": "8324:15:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "8363:4:0", + "nodeType": "YulLiteral", + "src": "8363:4:0", + "type": "", + "value": "0xe0" + }, + { + "name": "y", + "nativeSrc": "8369:1:0", + "nodeType": "YulIdentifier", + "src": "8369:1:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "8356:6:0", + "nodeType": "YulIdentifier", + "src": "8356:6:0" + }, + "nativeSrc": "8356:15:0", + "nodeType": "YulFunctionCall", + "src": "8356:15:0" + }, + "nativeSrc": "8356:15:0", + "nodeType": "YulExpressionStatement", + "src": "8356:15:0" + }, + { + "nativeSrc": "8388:68:0", + "nodeType": "YulAssignment", + "src": "8388:68:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "8399:7:0", + "nodeType": "YulIdentifier", + "src": "8399:7:0" + }, + { + "arguments": [ + { + "arguments": [], + "functionName": { + "name": "gas", + "nativeSrc": "8419:3:0", + "nodeType": "YulIdentifier", + "src": "8419:3:0" + }, + "nativeSrc": "8419:5:0", + "nodeType": "YulFunctionCall", + "src": "8419:5:0" + }, + { + "kind": "number", + "nativeSrc": "8426:4:0", + "nodeType": "YulLiteral", + "src": "8426:4:0", + "type": "", + "value": "0x06" + }, + { + "kind": "number", + "nativeSrc": "8432:4:0", + "nodeType": "YulLiteral", + "src": "8432:4:0", + "type": "", + "value": "0x80" + }, + { + "kind": "number", + "nativeSrc": "8438:4:0", + "nodeType": "YulLiteral", + "src": "8438:4:0", + "type": "", + "value": "0x80" + }, + { + "kind": "number", + "nativeSrc": "8444:4:0", + "nodeType": "YulLiteral", + "src": "8444:4:0", + "type": "", + "value": "0x80" + }, + { + "kind": "number", + "nativeSrc": "8450:4:0", + "nodeType": "YulLiteral", + "src": "8450:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "staticcall", + "nativeSrc": "8408:10:0", + "nodeType": "YulIdentifier", + "src": "8408:10:0" + }, + "nativeSrc": "8408:47:0", + "nodeType": "YulFunctionCall", + "src": "8408:47:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "8395:3:0", + "nodeType": "YulIdentifier", + "src": "8395:3:0" + }, + "nativeSrc": "8395:61:0", + "nodeType": "YulFunctionCall", + "src": "8395:61:0" + }, + "variableNames": [ + { + "name": "ret", + "nativeSrc": "8388:3:0", + "nodeType": "YulIdentifier", + "src": "8388:3:0" + } + ] + } + ] + }, + "name": "ec_add_tmp", + "nativeSrc": "8264:206:0", + "nodeType": "YulFunctionDefinition", + "parameters": [ + { + "name": "success", + "nativeSrc": "8284:7:0", + "nodeType": "YulTypedName", + "src": "8284:7:0", + "type": "" + }, + { + "name": "x", + "nativeSrc": "8293:1:0", + "nodeType": "YulTypedName", + "src": "8293:1:0", + "type": "" + }, + { + "name": "y", + "nativeSrc": "8296:1:0", + "nodeType": "YulTypedName", + "src": "8296:1:0", + "type": "" + } + ], + "returnVariables": [ + { + "name": "ret", + "nativeSrc": "8302:3:0", + "nodeType": "YulTypedName", + "src": "8302:3:0", + "type": "" + } + ], + "src": "8264:206:0" + }, + { + "body": { + "nativeSrc": "8623:137:0", + "nodeType": "YulBlock", + "src": "8623:137:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "8648:4:0", + "nodeType": "YulLiteral", + "src": "8648:4:0", + "type": "", + "value": "0xc0" + }, + { + "name": "scalar", + "nativeSrc": "8654:6:0", + "nodeType": "YulIdentifier", + "src": "8654:6:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "8641:6:0", + "nodeType": "YulIdentifier", + "src": "8641:6:0" + }, + "nativeSrc": "8641:20:0", + "nodeType": "YulFunctionCall", + "src": "8641:20:0" + }, + "nativeSrc": "8641:20:0", + "nodeType": "YulExpressionStatement", + "src": "8641:20:0" + }, + { + "nativeSrc": "8678:68:0", + "nodeType": "YulAssignment", + "src": "8678:68:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "8689:7:0", + "nodeType": "YulIdentifier", + "src": "8689:7:0" + }, + { + "arguments": [ + { + "arguments": [], + "functionName": { + "name": "gas", + "nativeSrc": "8709:3:0", + "nodeType": "YulIdentifier", + "src": "8709:3:0" + }, + "nativeSrc": "8709:5:0", + "nodeType": "YulFunctionCall", + "src": "8709:5:0" + }, + { + "kind": "number", + "nativeSrc": "8716:4:0", + "nodeType": "YulLiteral", + "src": "8716:4:0", + "type": "", + "value": "0x07" + }, + { + "kind": "number", + "nativeSrc": "8722:4:0", + "nodeType": "YulLiteral", + "src": "8722:4:0", + "type": "", + "value": "0x80" + }, + { + "kind": "number", + "nativeSrc": "8728:4:0", + "nodeType": "YulLiteral", + "src": "8728:4:0", + "type": "", + "value": "0x60" + }, + { + "kind": "number", + "nativeSrc": "8734:4:0", + "nodeType": "YulLiteral", + "src": "8734:4:0", + "type": "", + "value": "0x80" + }, + { + "kind": "number", + "nativeSrc": "8740:4:0", + "nodeType": "YulLiteral", + "src": "8740:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "staticcall", + "nativeSrc": "8698:10:0", + "nodeType": "YulIdentifier", + "src": "8698:10:0" + }, + "nativeSrc": "8698:47:0", + "nodeType": "YulFunctionCall", + "src": "8698:47:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "8685:3:0", + "nodeType": "YulIdentifier", + "src": "8685:3:0" + }, + "nativeSrc": "8685:61:0", + "nodeType": "YulFunctionCall", + "src": "8685:61:0" + }, + "variableNames": [ + { + "name": "ret", + "nativeSrc": "8678:3:0", + "nodeType": "YulIdentifier", + "src": "8678:3:0" + } + ] + } + ] + }, + "name": "ec_mul_tmp", + "nativeSrc": "8579:181:0", + "nodeType": "YulFunctionDefinition", + "parameters": [ + { + "name": "success", + "nativeSrc": "8599:7:0", + "nodeType": "YulTypedName", + "src": "8599:7:0", + "type": "" + }, + { + "name": "scalar", + "nativeSrc": "8608:6:0", + "nodeType": "YulTypedName", + "src": "8608:6:0", + "type": "" + } + ], + "returnVariables": [ + { + "name": "ret", + "nativeSrc": "8619:3:0", + "nodeType": "YulTypedName", + "src": "8619:3:0", + "type": "" + } + ], + "src": "8579:181:0" + }, + { + "body": { + "nativeSrc": "8917:710:0", + "nodeType": "YulBlock", + "src": "8917:710:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "8942:4:0", + "nodeType": "YulLiteral", + "src": "8942:4:0", + "type": "", + "value": "0x00" + }, + { + "name": "lhs_x", + "nativeSrc": "8948:5:0", + "nodeType": "YulIdentifier", + "src": "8948:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "8935:6:0", + "nodeType": "YulIdentifier", + "src": "8935:6:0" + }, + "nativeSrc": "8935:19:0", + "nodeType": "YulFunctionCall", + "src": "8935:19:0" + }, + "nativeSrc": "8935:19:0", + "nodeType": "YulExpressionStatement", + "src": "8935:19:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "8978:4:0", + "nodeType": "YulLiteral", + "src": "8978:4:0", + "type": "", + "value": "0x20" + }, + { + "name": "lhs_y", + "nativeSrc": "8984:5:0", + "nodeType": "YulIdentifier", + "src": "8984:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "8971:6:0", + "nodeType": "YulIdentifier", + "src": "8971:6:0" + }, + "nativeSrc": "8971:19:0", + "nodeType": "YulFunctionCall", + "src": "8971:19:0" + }, + "nativeSrc": "8971:19:0", + "nodeType": "YulExpressionStatement", + "src": "8971:19:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "9014:4:0", + "nodeType": "YulLiteral", + "src": "9014:4:0", + "type": "", + "value": "0x40" + }, + { + "arguments": [ + { + "name": "G2_X_1_MPTR", + "nativeSrc": "9026:11:0", + "nodeType": "YulIdentifier", + "src": "9026:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "9020:5:0", + "nodeType": "YulIdentifier", + "src": "9020:5:0" + }, + "nativeSrc": "9020:18:0", + "nodeType": "YulFunctionCall", + "src": "9020:18:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "9007:6:0", + "nodeType": "YulIdentifier", + "src": "9007:6:0" + }, + "nativeSrc": "9007:32:0", + "nodeType": "YulFunctionCall", + "src": "9007:32:0" + }, + "nativeSrc": "9007:32:0", + "nodeType": "YulExpressionStatement", + "src": "9007:32:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "9063:4:0", + "nodeType": "YulLiteral", + "src": "9063:4:0", + "type": "", + "value": "0x60" + }, + { + "arguments": [ + { + "name": "G2_X_2_MPTR", + "nativeSrc": "9075:11:0", + "nodeType": "YulIdentifier", + "src": "9075:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "9069:5:0", + "nodeType": "YulIdentifier", + "src": "9069:5:0" + }, + "nativeSrc": "9069:18:0", + "nodeType": "YulFunctionCall", + "src": "9069:18:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "9056:6:0", + "nodeType": "YulIdentifier", + "src": "9056:6:0" + }, + "nativeSrc": "9056:32:0", + "nodeType": "YulFunctionCall", + "src": "9056:32:0" + }, + "nativeSrc": "9056:32:0", + "nodeType": "YulExpressionStatement", + "src": "9056:32:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "9112:4:0", + "nodeType": "YulLiteral", + "src": "9112:4:0", + "type": "", + "value": "0x80" + }, + { + "arguments": [ + { + "name": "G2_Y_1_MPTR", + "nativeSrc": "9124:11:0", + "nodeType": "YulIdentifier", + "src": "9124:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "9118:5:0", + "nodeType": "YulIdentifier", + "src": "9118:5:0" + }, + "nativeSrc": "9118:18:0", + "nodeType": "YulFunctionCall", + "src": "9118:18:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "9105:6:0", + "nodeType": "YulIdentifier", + "src": "9105:6:0" + }, + "nativeSrc": "9105:32:0", + "nodeType": "YulFunctionCall", + "src": "9105:32:0" + }, + "nativeSrc": "9105:32:0", + "nodeType": "YulExpressionStatement", + "src": "9105:32:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "9161:4:0", + "nodeType": "YulLiteral", + "src": "9161:4:0", + "type": "", + "value": "0xa0" + }, + { + "arguments": [ + { + "name": "G2_Y_2_MPTR", + "nativeSrc": "9173:11:0", + "nodeType": "YulIdentifier", + "src": "9173:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "9167:5:0", + "nodeType": "YulIdentifier", + "src": "9167:5:0" + }, + "nativeSrc": "9167:18:0", + "nodeType": "YulFunctionCall", + "src": "9167:18:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "9154:6:0", + "nodeType": "YulIdentifier", + "src": "9154:6:0" + }, + "nativeSrc": "9154:32:0", + "nodeType": "YulFunctionCall", + "src": "9154:32:0" + }, + "nativeSrc": "9154:32:0", + "nodeType": "YulExpressionStatement", + "src": "9154:32:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "9210:4:0", + "nodeType": "YulLiteral", + "src": "9210:4:0", + "type": "", + "value": "0xc0" + }, + { + "name": "rhs_x", + "nativeSrc": "9216:5:0", + "nodeType": "YulIdentifier", + "src": "9216:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "9203:6:0", + "nodeType": "YulIdentifier", + "src": "9203:6:0" + }, + "nativeSrc": "9203:19:0", + "nodeType": "YulFunctionCall", + "src": "9203:19:0" + }, + "nativeSrc": "9203:19:0", + "nodeType": "YulExpressionStatement", + "src": "9203:19:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "9246:4:0", + "nodeType": "YulLiteral", + "src": "9246:4:0", + "type": "", + "value": "0xe0" + }, + { + "name": "rhs_y", + "nativeSrc": "9252:5:0", + "nodeType": "YulIdentifier", + "src": "9252:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "9239:6:0", + "nodeType": "YulIdentifier", + "src": "9239:6:0" + }, + "nativeSrc": "9239:19:0", + "nodeType": "YulFunctionCall", + "src": "9239:19:0" + }, + "nativeSrc": "9239:19:0", + "nodeType": "YulExpressionStatement", + "src": "9239:19:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "9282:5:0", + "nodeType": "YulLiteral", + "src": "9282:5:0", + "type": "", + "value": "0x100" + }, + { + "arguments": [ + { + "name": "NEG_S_G2_X_1_MPTR", + "nativeSrc": "9295:17:0", + "nodeType": "YulIdentifier", + "src": "9295:17:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "9289:5:0", + "nodeType": "YulIdentifier", + "src": "9289:5:0" + }, + "nativeSrc": "9289:24:0", + "nodeType": "YulFunctionCall", + "src": "9289:24:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "9275:6:0", + "nodeType": "YulIdentifier", + "src": "9275:6:0" + }, + "nativeSrc": "9275:39:0", + "nodeType": "YulFunctionCall", + "src": "9275:39:0" + }, + "nativeSrc": "9275:39:0", + "nodeType": "YulExpressionStatement", + "src": "9275:39:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "9338:5:0", + "nodeType": "YulLiteral", + "src": "9338:5:0", + "type": "", + "value": "0x120" + }, + { + "arguments": [ + { + "name": "NEG_S_G2_X_2_MPTR", + "nativeSrc": "9351:17:0", + "nodeType": "YulIdentifier", + "src": "9351:17:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "9345:5:0", + "nodeType": "YulIdentifier", + "src": "9345:5:0" + }, + "nativeSrc": "9345:24:0", + "nodeType": "YulFunctionCall", + "src": "9345:24:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "9331:6:0", + "nodeType": "YulIdentifier", + "src": "9331:6:0" + }, + "nativeSrc": "9331:39:0", + "nodeType": "YulFunctionCall", + "src": "9331:39:0" + }, + "nativeSrc": "9331:39:0", + "nodeType": "YulExpressionStatement", + "src": "9331:39:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "9394:5:0", + "nodeType": "YulLiteral", + "src": "9394:5:0", + "type": "", + "value": "0x140" + }, + { + "arguments": [ + { + "name": "NEG_S_G2_Y_1_MPTR", + "nativeSrc": "9407:17:0", + "nodeType": "YulIdentifier", + "src": "9407:17:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "9401:5:0", + "nodeType": "YulIdentifier", + "src": "9401:5:0" + }, + "nativeSrc": "9401:24:0", + "nodeType": "YulFunctionCall", + "src": "9401:24:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "9387:6:0", + "nodeType": "YulIdentifier", + "src": "9387:6:0" + }, + "nativeSrc": "9387:39:0", + "nodeType": "YulFunctionCall", + "src": "9387:39:0" + }, + "nativeSrc": "9387:39:0", + "nodeType": "YulExpressionStatement", + "src": "9387:39:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "9450:5:0", + "nodeType": "YulLiteral", + "src": "9450:5:0", + "type": "", + "value": "0x160" + }, + { + "arguments": [ + { + "name": "NEG_S_G2_Y_2_MPTR", + "nativeSrc": "9463:17:0", + "nodeType": "YulIdentifier", + "src": "9463:17:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "9457:5:0", + "nodeType": "YulIdentifier", + "src": "9457:5:0" + }, + "nativeSrc": "9457:24:0", + "nodeType": "YulFunctionCall", + "src": "9457:24:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "9443:6:0", + "nodeType": "YulIdentifier", + "src": "9443:6:0" + }, + "nativeSrc": "9443:39:0", + "nodeType": "YulFunctionCall", + "src": "9443:39:0" + }, + "nativeSrc": "9443:39:0", + "nodeType": "YulExpressionStatement", + "src": "9443:39:0" + }, + { + "nativeSrc": "9499:69:0", + "nodeType": "YulAssignment", + "src": "9499:69:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "9510:7:0", + "nodeType": "YulIdentifier", + "src": "9510:7:0" + }, + { + "arguments": [ + { + "arguments": [], + "functionName": { + "name": "gas", + "nativeSrc": "9530:3:0", + "nodeType": "YulIdentifier", + "src": "9530:3:0" + }, + "nativeSrc": "9530:5:0", + "nodeType": "YulFunctionCall", + "src": "9530:5:0" + }, + { + "kind": "number", + "nativeSrc": "9537:4:0", + "nodeType": "YulLiteral", + "src": "9537:4:0", + "type": "", + "value": "0x08" + }, + { + "kind": "number", + "nativeSrc": "9543:4:0", + "nodeType": "YulLiteral", + "src": "9543:4:0", + "type": "", + "value": "0x00" + }, + { + "kind": "number", + "nativeSrc": "9549:5:0", + "nodeType": "YulLiteral", + "src": "9549:5:0", + "type": "", + "value": "0x180" + }, + { + "kind": "number", + "nativeSrc": "9556:4:0", + "nodeType": "YulLiteral", + "src": "9556:4:0", + "type": "", + "value": "0x00" + }, + { + "kind": "number", + "nativeSrc": "9562:4:0", + "nodeType": "YulLiteral", + "src": "9562:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "staticcall", + "nativeSrc": "9519:10:0", + "nodeType": "YulIdentifier", + "src": "9519:10:0" + }, + "nativeSrc": "9519:48:0", + "nodeType": "YulFunctionCall", + "src": "9519:48:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "9506:3:0", + "nodeType": "YulIdentifier", + "src": "9506:3:0" + }, + "nativeSrc": "9506:62:0", + "nodeType": "YulFunctionCall", + "src": "9506:62:0" + }, + "variableNames": [ + { + "name": "ret", + "nativeSrc": "9499:3:0", + "nodeType": "YulIdentifier", + "src": "9499:3:0" + } + ] + }, + { + "nativeSrc": "9585:28:0", + "nodeType": "YulAssignment", + "src": "9585:28:0", + "value": { + "arguments": [ + { + "name": "ret", + "nativeSrc": "9596:3:0", + "nodeType": "YulIdentifier", + "src": "9596:3:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "9607:4:0", + "nodeType": "YulLiteral", + "src": "9607:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "9601:5:0", + "nodeType": "YulIdentifier", + "src": "9601:5:0" + }, + "nativeSrc": "9601:11:0", + "nodeType": "YulFunctionCall", + "src": "9601:11:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "9592:3:0", + "nodeType": "YulIdentifier", + "src": "9592:3:0" + }, + "nativeSrc": "9592:21:0", + "nodeType": "YulFunctionCall", + "src": "9592:21:0" + }, + "variableNames": [ + { + "name": "ret", + "nativeSrc": "9585:3:0", + "nodeType": "YulIdentifier", + "src": "9585:3:0" + } + ] + } + ] + }, + "name": "ec_pairing", + "nativeSrc": "8853:774:0", + "nodeType": "YulFunctionDefinition", + "parameters": [ + { + "name": "success", + "nativeSrc": "8873:7:0", + "nodeType": "YulTypedName", + "src": "8873:7:0", + "type": "" + }, + { + "name": "lhs_x", + "nativeSrc": "8882:5:0", + "nodeType": "YulTypedName", + "src": "8882:5:0", + "type": "" + }, + { + "name": "lhs_y", + "nativeSrc": "8889:5:0", + "nodeType": "YulTypedName", + "src": "8889:5:0", + "type": "" + }, + { + "name": "rhs_x", + "nativeSrc": "8896:5:0", + "nodeType": "YulTypedName", + "src": "8896:5:0", + "type": "" + }, + { + "name": "rhs_y", + "nativeSrc": "8903:5:0", + "nodeType": "YulTypedName", + "src": "8903:5:0", + "type": "" + } + ], + "returnVariables": [ + { + "name": "ret", + "nativeSrc": "8913:3:0", + "nodeType": "YulTypedName", + "src": "8913:3:0", + "type": "" + } + ], + "src": "8853:774:0" + }, + { + "nativeSrc": "9664:86:0", + "nodeType": "YulVariableDeclaration", + "src": "9664:86:0", + "value": { + "kind": "number", + "nativeSrc": "9673:77:0", + "nodeType": "YulLiteral", + "src": "9673:77:0", + "type": "", + "value": "21888242871839275222246405745257275088696311157297823662689037894645226208583" + }, + "variables": [ + { + "name": "q", + "nativeSrc": "9668:1:0", + "nodeType": "YulTypedName", + "src": "9668:1:0", + "type": "" + } + ] + }, + { + "nativeSrc": "9783:86:0", + "nodeType": "YulVariableDeclaration", + "src": "9783:86:0", + "value": { + "kind": "number", + "nativeSrc": "9792:77:0", + "nodeType": "YulLiteral", + "src": "9792:77:0", + "type": "", + "value": "21888242871839275222246405745257275088548364400416034343698204186575808495617" + }, + "variables": [ + { + "name": "r", + "nativeSrc": "9787:1:0", + "nodeType": "YulTypedName", + "src": "9787:1:0", + "type": "" + } + ] + }, + { + "nativeSrc": "9947:19:0", + "nodeType": "YulVariableDeclaration", + "src": "9947:19:0", + "value": { + "kind": "bool", + "nativeSrc": "9962:4:0", + "nodeType": "YulLiteral", + "src": "9962:4:0", + "type": "", + "value": "true" + }, + "variables": [ + { + "name": "success", + "nativeSrc": "9951:7:0", + "nodeType": "YulTypedName", + "src": "9951:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "9980:12639:0", + "nodeType": "YulBlock", + "src": "9980:12639:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "10044:6:0", + "nodeType": "YulLiteral", + "src": "10044:6:0", + "type": "", + "value": "0x05a0" + }, + { + "kind": "number", + "nativeSrc": "10052:66:0", + "nodeType": "YulLiteral", + "src": "10052:66:0", + "type": "", + "value": "0x02f5f088e7523e448f03748c0c8ebb1dd4720fd2bae0208200f8bbb2fa2f0c71" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "10037:6:0", + "nodeType": "YulIdentifier", + "src": "10037:6:0" + }, + "nativeSrc": "10037:82:0", + "nodeType": "YulFunctionCall", + "src": "10037:82:0" + }, + "nativeSrc": "10037:82:0", + "nodeType": "YulExpressionStatement", + "src": "10037:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "10156:6:0", + "nodeType": "YulLiteral", + "src": "10156:6:0", + "type": "", + "value": "0x05c0" + }, + { + "kind": "number", + "nativeSrc": "10164:66:0", + "nodeType": "YulLiteral", + "src": "10164:66:0", + "type": "", + "value": "0x000000000000000000000000000000000000000000000000000000000000000f" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "10149:6:0", + "nodeType": "YulIdentifier", + "src": "10149:6:0" + }, + "nativeSrc": "10149:82:0", + "nodeType": "YulFunctionCall", + "src": "10149:82:0" + }, + "nativeSrc": "10149:82:0", + "nodeType": "YulExpressionStatement", + "src": "10149:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "10260:6:0", + "nodeType": "YulLiteral", + "src": "10260:6:0", + "type": "", + "value": "0x05e0" + }, + { + "kind": "number", + "nativeSrc": "10268:66:0", + "nodeType": "YulLiteral", + "src": "10268:66:0", + "type": "", + "value": "0x3063edaa444bddc677fcd515f614555a777997e0a9287d1e62bf6dd004d82001" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "10253:6:0", + "nodeType": "YulIdentifier", + "src": "10253:6:0" + }, + "nativeSrc": "10253:82:0", + "nodeType": "YulFunctionCall", + "src": "10253:82:0" + }, + "nativeSrc": "10253:82:0", + "nodeType": "YulExpressionStatement", + "src": "10253:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "10368:6:0", + "nodeType": "YulLiteral", + "src": "10368:6:0", + "type": "", + "value": "0x0600" + }, + { + "kind": "number", + "nativeSrc": "10376:66:0", + "nodeType": "YulLiteral", + "src": "10376:66:0", + "type": "", + "value": "0x2b7ddfe4383c8d806530b94d3120ce6fcb511871e4d44a65f0acd0b96a8a942e" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "10361:6:0", + "nodeType": "YulIdentifier", + "src": "10361:6:0" + }, + "nativeSrc": "10361:82:0", + "nodeType": "YulFunctionCall", + "src": "10361:82:0" + }, + "nativeSrc": "10361:82:0", + "nodeType": "YulExpressionStatement", + "src": "10361:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "10476:6:0", + "nodeType": "YulLiteral", + "src": "10476:6:0", + "type": "", + "value": "0x0620" + }, + { + "kind": "number", + "nativeSrc": "10484:66:0", + "nodeType": "YulLiteral", + "src": "10484:66:0", + "type": "", + "value": "0x1f67bc4574eaef5e630a13c710221a3e3d491e59fddabaf321e56f3ca8d91624" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "10469:6:0", + "nodeType": "YulIdentifier", + "src": "10469:6:0" + }, + "nativeSrc": "10469:82:0", + "nodeType": "YulFunctionCall", + "src": "10469:82:0" + }, + "nativeSrc": "10469:82:0", + "nodeType": "YulExpressionStatement", + "src": "10469:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "10588:6:0", + "nodeType": "YulLiteral", + "src": "10588:6:0", + "type": "", + "value": "0x0640" + }, + { + "kind": "number", + "nativeSrc": "10596:66:0", + "nodeType": "YulLiteral", + "src": "10596:66:0", + "type": "", + "value": "0x2427343dea588e4242e165ef52d4c1f5986149f372f5c87534f7f6274ef4eeff" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "10581:6:0", + "nodeType": "YulIdentifier", + "src": "10581:6:0" + }, + "nativeSrc": "10581:82:0", + "nodeType": "YulFunctionCall", + "src": "10581:82:0" + }, + "nativeSrc": "10581:82:0", + "nodeType": "YulExpressionStatement", + "src": "10581:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "10705:6:0", + "nodeType": "YulLiteral", + "src": "10705:6:0", + "type": "", + "value": "0x0660" + }, + { + "kind": "number", + "nativeSrc": "10713:66:0", + "nodeType": "YulLiteral", + "src": "10713:66:0", + "type": "", + "value": "0x0000000000000000000000000000000000000000000000000000000000000005" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "10698:6:0", + "nodeType": "YulIdentifier", + "src": "10698:6:0" + }, + "nativeSrc": "10698:82:0", + "nodeType": "YulFunctionCall", + "src": "10698:82:0" + }, + "nativeSrc": "10698:82:0", + "nodeType": "YulExpressionStatement", + "src": "10698:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "10821:6:0", + "nodeType": "YulLiteral", + "src": "10821:6:0", + "type": "", + "value": "0x0680" + }, + { + "kind": "number", + "nativeSrc": "10829:66:0", + "nodeType": "YulLiteral", + "src": "10829:66:0", + "type": "", + "value": "0x0000000000000000000000000000000000000000000000000000000000000000" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "10814:6:0", + "nodeType": "YulIdentifier", + "src": "10814:6:0" + }, + "nativeSrc": "10814:82:0", + "nodeType": "YulFunctionCall", + "src": "10814:82:0" + }, + "nativeSrc": "10814:82:0", + "nodeType": "YulExpressionStatement", + "src": "10814:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "10939:6:0", + "nodeType": "YulLiteral", + "src": "10939:6:0", + "type": "", + "value": "0x06a0" + }, + { + "kind": "number", + "nativeSrc": "10947:66:0", + "nodeType": "YulLiteral", + "src": "10947:66:0", + "type": "", + "value": "0x0000000000000000000000000000000000000000000000000000000000000000" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "10932:6:0", + "nodeType": "YulIdentifier", + "src": "10932:6:0" + }, + "nativeSrc": "10932:82:0", + "nodeType": "YulFunctionCall", + "src": "10932:82:0" + }, + "nativeSrc": "10932:82:0", + "nodeType": "YulExpressionStatement", + "src": "10932:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "11052:6:0", + "nodeType": "YulLiteral", + "src": "11052:6:0", + "type": "", + "value": "0x06c0" + }, + { + "kind": "number", + "nativeSrc": "11060:66:0", + "nodeType": "YulLiteral", + "src": "11060:66:0", + "type": "", + "value": "0x0000000000000000000000000000000000000000000000000000000000000000" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "11045:6:0", + "nodeType": "YulIdentifier", + "src": "11045:6:0" + }, + "nativeSrc": "11045:82:0", + "nodeType": "YulFunctionCall", + "src": "11045:82:0" + }, + "nativeSrc": "11045:82:0", + "nodeType": "YulExpressionStatement", + "src": "11045:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "11168:6:0", + "nodeType": "YulLiteral", + "src": "11168:6:0", + "type": "", + "value": "0x06e0" + }, + { + "kind": "number", + "nativeSrc": "11176:66:0", + "nodeType": "YulLiteral", + "src": "11176:66:0", + "type": "", + "value": "0x0000000000000000000000000000000000000000000000000000000000000000" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "11161:6:0", + "nodeType": "YulIdentifier", + "src": "11161:6:0" + }, + "nativeSrc": "11161:82:0", + "nodeType": "YulFunctionCall", + "src": "11161:82:0" + }, + "nativeSrc": "11161:82:0", + "nodeType": "YulExpressionStatement", + "src": "11161:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "11288:6:0", + "nodeType": "YulLiteral", + "src": "11288:6:0", + "type": "", + "value": "0x0700" + }, + { + "kind": "number", + "nativeSrc": "11296:66:0", + "nodeType": "YulLiteral", + "src": "11296:66:0", + "type": "", + "value": "0x0000000000000000000000000000000000000000000000000000000000000001" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "11281:6:0", + "nodeType": "YulIdentifier", + "src": "11281:6:0" + }, + "nativeSrc": "11281:82:0", + "nodeType": "YulFunctionCall", + "src": "11281:82:0" + }, + "nativeSrc": "11281:82:0", + "nodeType": "YulExpressionStatement", + "src": "11281:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "11395:6:0", + "nodeType": "YulLiteral", + "src": "11395:6:0", + "type": "", + "value": "0x0720" + }, + { + "kind": "number", + "nativeSrc": "11403:66:0", + "nodeType": "YulLiteral", + "src": "11403:66:0", + "type": "", + "value": "0x0000000000000000000000000000000000000000000000000000000000000002" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "11388:6:0", + "nodeType": "YulIdentifier", + "src": "11388:6:0" + }, + "nativeSrc": "11388:82:0", + "nodeType": "YulFunctionCall", + "src": "11388:82:0" + }, + "nativeSrc": "11388:82:0", + "nodeType": "YulExpressionStatement", + "src": "11388:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "11502:6:0", + "nodeType": "YulLiteral", + "src": "11502:6:0", + "type": "", + "value": "0x0740" + }, + { + "kind": "number", + "nativeSrc": "11510:66:0", + "nodeType": "YulLiteral", + "src": "11510:66:0", + "type": "", + "value": "0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "11495:6:0", + "nodeType": "YulIdentifier", + "src": "11495:6:0" + }, + "nativeSrc": "11495:82:0", + "nodeType": "YulFunctionCall", + "src": "11495:82:0" + }, + "nativeSrc": "11495:82:0", + "nodeType": "YulExpressionStatement", + "src": "11495:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "11611:6:0", + "nodeType": "YulLiteral", + "src": "11611:6:0", + "type": "", + "value": "0x0760" + }, + { + "kind": "number", + "nativeSrc": "11619:66:0", + "nodeType": "YulLiteral", + "src": "11619:66:0", + "type": "", + "value": "0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "11604:6:0", + "nodeType": "YulIdentifier", + "src": "11604:6:0" + }, + "nativeSrc": "11604:82:0", + "nodeType": "YulFunctionCall", + "src": "11604:82:0" + }, + "nativeSrc": "11604:82:0", + "nodeType": "YulExpressionStatement", + "src": "11604:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "11720:6:0", + "nodeType": "YulLiteral", + "src": "11720:6:0", + "type": "", + "value": "0x0780" + }, + { + "kind": "number", + "nativeSrc": "11728:66:0", + "nodeType": "YulLiteral", + "src": "11728:66:0", + "type": "", + "value": "0x090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "11713:6:0", + "nodeType": "YulIdentifier", + "src": "11713:6:0" + }, + "nativeSrc": "11713:82:0", + "nodeType": "YulFunctionCall", + "src": "11713:82:0" + }, + "nativeSrc": "11713:82:0", + "nodeType": "YulExpressionStatement", + "src": "11713:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "11829:6:0", + "nodeType": "YulLiteral", + "src": "11829:6:0", + "type": "", + "value": "0x07a0" + }, + { + "kind": "number", + "nativeSrc": "11837:66:0", + "nodeType": "YulLiteral", + "src": "11837:66:0", + "type": "", + "value": "0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "11822:6:0", + "nodeType": "YulIdentifier", + "src": "11822:6:0" + }, + "nativeSrc": "11822:82:0", + "nodeType": "YulFunctionCall", + "src": "11822:82:0" + }, + "nativeSrc": "11822:82:0", + "nodeType": "YulExpressionStatement", + "src": "11822:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "11938:6:0", + "nodeType": "YulLiteral", + "src": "11938:6:0", + "type": "", + "value": "0x07c0" + }, + { + "kind": "number", + "nativeSrc": "11946:66:0", + "nodeType": "YulLiteral", + "src": "11946:66:0", + "type": "", + "value": "0x186282957db913abd99f91db59fe69922e95040603ef44c0bd7aa3adeef8f5ac" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "11931:6:0", + "nodeType": "YulIdentifier", + "src": "11931:6:0" + }, + "nativeSrc": "11931:82:0", + "nodeType": "YulFunctionCall", + "src": "11931:82:0" + }, + "nativeSrc": "11931:82:0", + "nodeType": "YulExpressionStatement", + "src": "11931:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "12053:6:0", + "nodeType": "YulLiteral", + "src": "12053:6:0", + "type": "", + "value": "0x07e0" + }, + { + "kind": "number", + "nativeSrc": "12061:66:0", + "nodeType": "YulLiteral", + "src": "12061:66:0", + "type": "", + "value": "0x17944351223333f260ddc3b4af45191b856689eda9eab5cbcddbbe570ce860d2" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "12046:6:0", + "nodeType": "YulIdentifier", + "src": "12046:6:0" + }, + "nativeSrc": "12046:82:0", + "nodeType": "YulFunctionCall", + "src": "12046:82:0" + }, + "nativeSrc": "12046:82:0", + "nodeType": "YulExpressionStatement", + "src": "12046:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "12168:6:0", + "nodeType": "YulLiteral", + "src": "12168:6:0", + "type": "", + "value": "0x0800" + }, + { + "kind": "number", + "nativeSrc": "12176:66:0", + "nodeType": "YulLiteral", + "src": "12176:66:0", + "type": "", + "value": "0x06d971ff4a7467c3ec596ed6efc674572e32fd6f52b721f97e35b0b3d3546753" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "12161:6:0", + "nodeType": "YulIdentifier", + "src": "12161:6:0" + }, + "nativeSrc": "12161:82:0", + "nodeType": "YulFunctionCall", + "src": "12161:82:0" + }, + "nativeSrc": "12161:82:0", + "nodeType": "YulExpressionStatement", + "src": "12161:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "12283:6:0", + "nodeType": "YulLiteral", + "src": "12283:6:0", + "type": "", + "value": "0x0820" + }, + { + "kind": "number", + "nativeSrc": "12291:66:0", + "nodeType": "YulLiteral", + "src": "12291:66:0", + "type": "", + "value": "0x06ecdb9f9567f59ed2eee36e1e1d58797fd13cc97fafc2910f5e8a12f202fa9a" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "12276:6:0", + "nodeType": "YulIdentifier", + "src": "12276:6:0" + }, + "nativeSrc": "12276:82:0", + "nodeType": "YulFunctionCall", + "src": "12276:82:0" + }, + "nativeSrc": "12276:82:0", + "nodeType": "YulExpressionStatement", + "src": "12276:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "12398:6:0", + "nodeType": "YulLiteral", + "src": "12398:6:0", + "type": "", + "value": "0x0840" + }, + { + "kind": "number", + "nativeSrc": "12406:66:0", + "nodeType": "YulLiteral", + "src": "12406:66:0", + "type": "", + "value": "0x0501be0946f811e8f591574fa619561974c951568d9fbcd05b5191fd056b2417" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "12391:6:0", + "nodeType": "YulIdentifier", + "src": "12391:6:0" + }, + "nativeSrc": "12391:82:0", + "nodeType": "YulFunctionCall", + "src": "12391:82:0" + }, + "nativeSrc": "12391:82:0", + "nodeType": "YulExpressionStatement", + "src": "12391:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "12517:6:0", + "nodeType": "YulLiteral", + "src": "12517:6:0", + "type": "", + "value": "0x0860" + }, + { + "kind": "number", + "nativeSrc": "12525:66:0", + "nodeType": "YulLiteral", + "src": "12525:66:0", + "type": "", + "value": "0x223dedcfac010cb3f7b9b66e6d3c77a475fc563e75bc7f375e70ec92ad6aa0ee" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "12510:6:0", + "nodeType": "YulIdentifier", + "src": "12510:6:0" + }, + "nativeSrc": "12510:82:0", + "nodeType": "YulFunctionCall", + "src": "12510:82:0" + }, + "nativeSrc": "12510:82:0", + "nodeType": "YulExpressionStatement", + "src": "12510:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "12636:6:0", + "nodeType": "YulLiteral", + "src": "12636:6:0", + "type": "", + "value": "0x0880" + }, + { + "kind": "number", + "nativeSrc": "12644:66:0", + "nodeType": "YulLiteral", + "src": "12644:66:0", + "type": "", + "value": "0x22b4fd8f0081b45c4ada66549f3676ee8dbf6a644ed9303d216e237bb6c0608e" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "12629:6:0", + "nodeType": "YulIdentifier", + "src": "12629:6:0" + }, + "nativeSrc": "12629:82:0", + "nodeType": "YulFunctionCall", + "src": "12629:82:0" + }, + "nativeSrc": "12629:82:0", + "nodeType": "YulExpressionStatement", + "src": "12629:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "12755:6:0", + "nodeType": "YulLiteral", + "src": "12755:6:0", + "type": "", + "value": "0x08a0" + }, + { + "kind": "number", + "nativeSrc": "12763:66:0", + "nodeType": "YulLiteral", + "src": "12763:66:0", + "type": "", + "value": "0x0909a928f105ee7bdbb8f7c3fcc5cbbda66b25aa3d32cdc702364ac4b588c21f" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "12748:6:0", + "nodeType": "YulIdentifier", + "src": "12748:6:0" + }, + "nativeSrc": "12748:82:0", + "nodeType": "YulFunctionCall", + "src": "12748:82:0" + }, + "nativeSrc": "12748:82:0", + "nodeType": "YulExpressionStatement", + "src": "12748:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "12874:6:0", + "nodeType": "YulLiteral", + "src": "12874:6:0", + "type": "", + "value": "0x08c0" + }, + { + "kind": "number", + "nativeSrc": "12882:66:0", + "nodeType": "YulLiteral", + "src": "12882:66:0", + "type": "", + "value": "0x1881ab4a3e63c34f3711b0d9ed2d433efbdaca4d328e9c022c0b875307499235" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "12867:6:0", + "nodeType": "YulIdentifier", + "src": "12867:6:0" + }, + "nativeSrc": "12867:82:0", + "nodeType": "YulFunctionCall", + "src": "12867:82:0" + }, + "nativeSrc": "12867:82:0", + "nodeType": "YulExpressionStatement", + "src": "12867:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "12993:6:0", + "nodeType": "YulLiteral", + "src": "12993:6:0", + "type": "", + "value": "0x08e0" + }, + { + "kind": "number", + "nativeSrc": "13001:66:0", + "nodeType": "YulLiteral", + "src": "13001:66:0", + "type": "", + "value": "0x1789ba3c9254479c4c57a0ae4cce23a20fd0b13282530af07bf30535ba0c9370" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "12986:6:0", + "nodeType": "YulIdentifier", + "src": "12986:6:0" + }, + "nativeSrc": "12986:82:0", + "nodeType": "YulFunctionCall", + "src": "12986:82:0" + }, + "nativeSrc": "12986:82:0", + "nodeType": "YulExpressionStatement", + "src": "12986:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "13112:6:0", + "nodeType": "YulLiteral", + "src": "13112:6:0", + "type": "", + "value": "0x0900" + }, + { + "kind": "number", + "nativeSrc": "13120:66:0", + "nodeType": "YulLiteral", + "src": "13120:66:0", + "type": "", + "value": "0x17561f0202b7c0589ee6db530c32222b112d26e60a434a9d2293f1bffd84c94f" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "13105:6:0", + "nodeType": "YulIdentifier", + "src": "13105:6:0" + }, + "nativeSrc": "13105:82:0", + "nodeType": "YulFunctionCall", + "src": "13105:82:0" + }, + "nativeSrc": "13105:82:0", + "nodeType": "YulExpressionStatement", + "src": "13105:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "13231:6:0", + "nodeType": "YulLiteral", + "src": "13231:6:0", + "type": "", + "value": "0x0920" + }, + { + "kind": "number", + "nativeSrc": "13239:66:0", + "nodeType": "YulLiteral", + "src": "13239:66:0", + "type": "", + "value": "0x2e761f6cd423b059876be5f565721795532aaf6e5f4adf0a646cf3e19a57c88f" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "13224:6:0", + "nodeType": "YulIdentifier", + "src": "13224:6:0" + }, + "nativeSrc": "13224:82:0", + "nodeType": "YulFunctionCall", + "src": "13224:82:0" + }, + "nativeSrc": "13224:82:0", + "nodeType": "YulExpressionStatement", + "src": "13224:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "13350:6:0", + "nodeType": "YulLiteral", + "src": "13350:6:0", + "type": "", + "value": "0x0940" + }, + { + "kind": "number", + "nativeSrc": "13358:66:0", + "nodeType": "YulLiteral", + "src": "13358:66:0", + "type": "", + "value": "0x2bed90317c7537fbacad8286a82cdcf7501bbaf1778049358c4e736ed1418221" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "13343:6:0", + "nodeType": "YulIdentifier", + "src": "13343:6:0" + }, + "nativeSrc": "13343:82:0", + "nodeType": "YulFunctionCall", + "src": "13343:82:0" + }, + "nativeSrc": "13343:82:0", + "nodeType": "YulExpressionStatement", + "src": "13343:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "13469:6:0", + "nodeType": "YulLiteral", + "src": "13469:6:0", + "type": "", + "value": "0x0960" + }, + { + "kind": "number", + "nativeSrc": "13477:66:0", + "nodeType": "YulLiteral", + "src": "13477:66:0", + "type": "", + "value": "0x14e61718ff54051b7173543df240b2b11696857fd4d475f165b71a312f7e1b8b" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "13462:6:0", + "nodeType": "YulIdentifier", + "src": "13462:6:0" + }, + "nativeSrc": "13462:82:0", + "nodeType": "YulFunctionCall", + "src": "13462:82:0" + }, + "nativeSrc": "13462:82:0", + "nodeType": "YulExpressionStatement", + "src": "13462:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "13588:6:0", + "nodeType": "YulLiteral", + "src": "13588:6:0", + "type": "", + "value": "0x0980" + }, + { + "kind": "number", + "nativeSrc": "13596:66:0", + "nodeType": "YulLiteral", + "src": "13596:66:0", + "type": "", + "value": "0x0a486dfbdad2cd6a49b00a40d56435843ce57800600f250c95ca31aafd5a9ca9" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "13581:6:0", + "nodeType": "YulIdentifier", + "src": "13581:6:0" + }, + "nativeSrc": "13581:82:0", + "nodeType": "YulFunctionCall", + "src": "13581:82:0" + }, + "nativeSrc": "13581:82:0", + "nodeType": "YulExpressionStatement", + "src": "13581:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "13707:6:0", + "nodeType": "YulLiteral", + "src": "13707:6:0", + "type": "", + "value": "0x09a0" + }, + { + "kind": "number", + "nativeSrc": "13715:66:0", + "nodeType": "YulLiteral", + "src": "13715:66:0", + "type": "", + "value": "0x0c3d2c59acfc8e87007adc8dfd9237d25f0f8d7592a3243cc3d3bfbf3c0c95bb" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "13700:6:0", + "nodeType": "YulIdentifier", + "src": "13700:6:0" + }, + "nativeSrc": "13700:82:0", + "nodeType": "YulFunctionCall", + "src": "13700:82:0" + }, + "nativeSrc": "13700:82:0", + "nodeType": "YulExpressionStatement", + "src": "13700:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "13826:6:0", + "nodeType": "YulLiteral", + "src": "13826:6:0", + "type": "", + "value": "0x09c0" + }, + { + "kind": "number", + "nativeSrc": "13834:66:0", + "nodeType": "YulLiteral", + "src": "13834:66:0", + "type": "", + "value": "0x1c5d502189ca88f62a21ea421b11f3e52dd7f3ed65f1c476b5af7828281042bd" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "13819:6:0", + "nodeType": "YulIdentifier", + "src": "13819:6:0" + }, + "nativeSrc": "13819:82:0", + "nodeType": "YulFunctionCall", + "src": "13819:82:0" + }, + "nativeSrc": "13819:82:0", + "nodeType": "YulExpressionStatement", + "src": "13819:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "13945:6:0", + "nodeType": "YulLiteral", + "src": "13945:6:0", + "type": "", + "value": "0x09e0" + }, + { + "kind": "number", + "nativeSrc": "13953:66:0", + "nodeType": "YulLiteral", + "src": "13953:66:0", + "type": "", + "value": "0x16007eac180040aef3b12049fdd2d508fe384233f087ad33166fa8f7a49bedb2" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "13938:6:0", + "nodeType": "YulIdentifier", + "src": "13938:6:0" + }, + "nativeSrc": "13938:82:0", + "nodeType": "YulFunctionCall", + "src": "13938:82:0" + }, + "nativeSrc": "13938:82:0", + "nodeType": "YulExpressionStatement", + "src": "13938:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "14064:6:0", + "nodeType": "YulLiteral", + "src": "14064:6:0", + "type": "", + "value": "0x0a00" + }, + { + "kind": "number", + "nativeSrc": "14072:66:0", + "nodeType": "YulLiteral", + "src": "14072:66:0", + "type": "", + "value": "0x225516832533d34ead36467cab52fe1234e431151435403d4edfbb4034322570" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "14057:6:0", + "nodeType": "YulIdentifier", + "src": "14057:6:0" + }, + "nativeSrc": "14057:82:0", + "nodeType": "YulFunctionCall", + "src": "14057:82:0" + }, + "nativeSrc": "14057:82:0", + "nodeType": "YulExpressionStatement", + "src": "14057:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "14183:6:0", + "nodeType": "YulLiteral", + "src": "14183:6:0", + "type": "", + "value": "0x0a20" + }, + { + "kind": "number", + "nativeSrc": "14191:66:0", + "nodeType": "YulLiteral", + "src": "14191:66:0", + "type": "", + "value": "0x19a823d3a8bccf01ccc3ee2edc7ebc45f7ecec078176995b89eb9a8538993b5d" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "14176:6:0", + "nodeType": "YulIdentifier", + "src": "14176:6:0" + }, + "nativeSrc": "14176:82:0", + "nodeType": "YulFunctionCall", + "src": "14176:82:0" + }, + "nativeSrc": "14176:82:0", + "nodeType": "YulExpressionStatement", + "src": "14176:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "14302:6:0", + "nodeType": "YulLiteral", + "src": "14302:6:0", + "type": "", + "value": "0x0a40" + }, + { + "kind": "number", + "nativeSrc": "14310:66:0", + "nodeType": "YulLiteral", + "src": "14310:66:0", + "type": "", + "value": "0x05656fa2fd3e996812b83953f4c4fa065320a64abbc41b9c5e3b45705e96bfce" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "14295:6:0", + "nodeType": "YulIdentifier", + "src": "14295:6:0" + }, + "nativeSrc": "14295:82:0", + "nodeType": "YulFunctionCall", + "src": "14295:82:0" + }, + "nativeSrc": "14295:82:0", + "nodeType": "YulExpressionStatement", + "src": "14295:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "14421:6:0", + "nodeType": "YulLiteral", + "src": "14421:6:0", + "type": "", + "value": "0x0a60" + }, + { + "kind": "number", + "nativeSrc": "14429:66:0", + "nodeType": "YulLiteral", + "src": "14429:66:0", + "type": "", + "value": "0x01ecda53a3163f2d88b90eb747de24ae2e32458656e7672e42471a3cb3007bcb" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "14414:6:0", + "nodeType": "YulIdentifier", + "src": "14414:6:0" + }, + "nativeSrc": "14414:82:0", + "nodeType": "YulFunctionCall", + "src": "14414:82:0" + }, + "nativeSrc": "14414:82:0", + "nodeType": "YulExpressionStatement", + "src": "14414:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "14540:6:0", + "nodeType": "YulLiteral", + "src": "14540:6:0", + "type": "", + "value": "0x0a80" + }, + { + "kind": "number", + "nativeSrc": "14548:66:0", + "nodeType": "YulLiteral", + "src": "14548:66:0", + "type": "", + "value": "0x15f8a194720ed30a9e1e8754fa1d983b8215fd5c5f2d43916ee46bfcad9d141b" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "14533:6:0", + "nodeType": "YulIdentifier", + "src": "14533:6:0" + }, + "nativeSrc": "14533:82:0", + "nodeType": "YulFunctionCall", + "src": "14533:82:0" + }, + "nativeSrc": "14533:82:0", + "nodeType": "YulExpressionStatement", + "src": "14533:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "14659:6:0", + "nodeType": "YulLiteral", + "src": "14659:6:0", + "type": "", + "value": "0x0aa0" + }, + { + "kind": "number", + "nativeSrc": "14667:66:0", + "nodeType": "YulLiteral", + "src": "14667:66:0", + "type": "", + "value": "0x1d6f775ba1406ddd99a63e6f4eaf3c4f86aa59537c1f8425478c2d17f7d6199b" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "14652:6:0", + "nodeType": "YulIdentifier", + "src": "14652:6:0" + }, + "nativeSrc": "14652:82:0", + "nodeType": "YulFunctionCall", + "src": "14652:82:0" + }, + "nativeSrc": "14652:82:0", + "nodeType": "YulExpressionStatement", + "src": "14652:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "14778:6:0", + "nodeType": "YulLiteral", + "src": "14778:6:0", + "type": "", + "value": "0x0ac0" + }, + { + "kind": "number", + "nativeSrc": "14786:66:0", + "nodeType": "YulLiteral", + "src": "14786:66:0", + "type": "", + "value": "0x0853cbd7af517e0e7576455adfd87667cca8966a814484ac18f54b3a49eedd6b" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "14771:6:0", + "nodeType": "YulIdentifier", + "src": "14771:6:0" + }, + "nativeSrc": "14771:82:0", + "nodeType": "YulFunctionCall", + "src": "14771:82:0" + }, + "nativeSrc": "14771:82:0", + "nodeType": "YulExpressionStatement", + "src": "14771:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "14898:6:0", + "nodeType": "YulLiteral", + "src": "14898:6:0", + "type": "", + "value": "0x0ae0" + }, + { + "kind": "number", + "nativeSrc": "14906:66:0", + "nodeType": "YulLiteral", + "src": "14906:66:0", + "type": "", + "value": "0x289538aa549b7f126880ebb4912eac428b43fe22f4fa15b534ad9954fc87a3eb" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "14891:6:0", + "nodeType": "YulIdentifier", + "src": "14891:6:0" + }, + "nativeSrc": "14891:82:0", + "nodeType": "YulFunctionCall", + "src": "14891:82:0" + }, + "nativeSrc": "14891:82:0", + "nodeType": "YulExpressionStatement", + "src": "14891:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "15018:6:0", + "nodeType": "YulLiteral", + "src": "15018:6:0", + "type": "", + "value": "0x0b00" + }, + { + "kind": "number", + "nativeSrc": "15026:66:0", + "nodeType": "YulLiteral", + "src": "15026:66:0", + "type": "", + "value": "0x10fb7c07ce1eca621162b8ed526391b44f0772f2f0a14c657fc6cb9eb2efad47" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "15011:6:0", + "nodeType": "YulIdentifier", + "src": "15011:6:0" + }, + "nativeSrc": "15011:82:0", + "nodeType": "YulFunctionCall", + "src": "15011:82:0" + }, + "nativeSrc": "15011:82:0", + "nodeType": "YulExpressionStatement", + "src": "15011:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "15138:6:0", + "nodeType": "YulLiteral", + "src": "15138:6:0", + "type": "", + "value": "0x0b20" + }, + { + "kind": "number", + "nativeSrc": "15146:66:0", + "nodeType": "YulLiteral", + "src": "15146:66:0", + "type": "", + "value": "0x25b711a62466fa8dff76f54d8fa9b2149710affdf7899e7b0f026b555a09119c" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "15131:6:0", + "nodeType": "YulIdentifier", + "src": "15131:6:0" + }, + "nativeSrc": "15131:82:0", + "nodeType": "YulFunctionCall", + "src": "15131:82:0" + }, + "nativeSrc": "15131:82:0", + "nodeType": "YulExpressionStatement", + "src": "15131:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "15258:6:0", + "nodeType": "YulLiteral", + "src": "15258:6:0", + "type": "", + "value": "0x0b40" + }, + { + "kind": "number", + "nativeSrc": "15266:66:0", + "nodeType": "YulLiteral", + "src": "15266:66:0", + "type": "", + "value": "0x2e0d1a637445ee1030f1106da84f2df53fd41ac850e00cae29f97eccca3e0497" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "15251:6:0", + "nodeType": "YulIdentifier", + "src": "15251:6:0" + }, + "nativeSrc": "15251:82:0", + "nodeType": "YulFunctionCall", + "src": "15251:82:0" + }, + "nativeSrc": "15251:82:0", + "nodeType": "YulExpressionStatement", + "src": "15251:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "15383:6:0", + "nodeType": "YulLiteral", + "src": "15383:6:0", + "type": "", + "value": "0x0b60" + }, + { + "kind": "number", + "nativeSrc": "15391:66:0", + "nodeType": "YulLiteral", + "src": "15391:66:0", + "type": "", + "value": "0x258c27b168eba74957335b2a08c2e0925534415a076203cb91981cff6ce16c7b" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "15376:6:0", + "nodeType": "YulIdentifier", + "src": "15376:6:0" + }, + "nativeSrc": "15376:82:0", + "nodeType": "YulFunctionCall", + "src": "15376:82:0" + }, + "nativeSrc": "15376:82:0", + "nodeType": "YulExpressionStatement", + "src": "15376:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "15508:6:0", + "nodeType": "YulLiteral", + "src": "15508:6:0", + "type": "", + "value": "0x0b80" + }, + { + "kind": "number", + "nativeSrc": "15516:66:0", + "nodeType": "YulLiteral", + "src": "15516:66:0", + "type": "", + "value": "0x2cbb60a7ad0f14c76954f575d966cc2ea736eb296de01bf26f8c3d7aaf79b639" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "15501:6:0", + "nodeType": "YulIdentifier", + "src": "15501:6:0" + }, + "nativeSrc": "15501:82:0", + "nodeType": "YulFunctionCall", + "src": "15501:82:0" + }, + "nativeSrc": "15501:82:0", + "nodeType": "YulExpressionStatement", + "src": "15501:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "15633:6:0", + "nodeType": "YulLiteral", + "src": "15633:6:0", + "type": "", + "value": "0x0ba0" + }, + { + "kind": "number", + "nativeSrc": "15641:66:0", + "nodeType": "YulLiteral", + "src": "15641:66:0", + "type": "", + "value": "0x2b6ccc3d1aafee7de009bf8080e45ccc090e4e7eb0c6b54c08f88669bb69d42a" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "15626:6:0", + "nodeType": "YulIdentifier", + "src": "15626:6:0" + }, + "nativeSrc": "15626:82:0", + "nodeType": "YulFunctionCall", + "src": "15626:82:0" + }, + "nativeSrc": "15626:82:0", + "nodeType": "YulExpressionStatement", + "src": "15626:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "15758:6:0", + "nodeType": "YulLiteral", + "src": "15758:6:0", + "type": "", + "value": "0x0bc0" + }, + { + "kind": "number", + "nativeSrc": "15766:66:0", + "nodeType": "YulLiteral", + "src": "15766:66:0", + "type": "", + "value": "0x126cf24b399605dfbd9c94652fee8bacbfd977b9aad4d6c387f6a203cc8d6146" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "15751:6:0", + "nodeType": "YulIdentifier", + "src": "15751:6:0" + }, + "nativeSrc": "15751:82:0", + "nodeType": "YulFunctionCall", + "src": "15751:82:0" + }, + "nativeSrc": "15751:82:0", + "nodeType": "YulExpressionStatement", + "src": "15751:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "15883:6:0", + "nodeType": "YulLiteral", + "src": "15883:6:0", + "type": "", + "value": "0x0be0" + }, + { + "kind": "number", + "nativeSrc": "15891:66:0", + "nodeType": "YulLiteral", + "src": "15891:66:0", + "type": "", + "value": "0x14d822430fad56cd0cb7f164c5603c9ea0e77912b77d316cce2b80a4989dd12c" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "15876:6:0", + "nodeType": "YulIdentifier", + "src": "15876:6:0" + }, + "nativeSrc": "15876:82:0", + "nodeType": "YulFunctionCall", + "src": "15876:82:0" + }, + "nativeSrc": "15876:82:0", + "nodeType": "YulExpressionStatement", + "src": "15876:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "16008:6:0", + "nodeType": "YulLiteral", + "src": "16008:6:0", + "type": "", + "value": "0x0c00" + }, + { + "kind": "number", + "nativeSrc": "16016:66:0", + "nodeType": "YulLiteral", + "src": "16016:66:0", + "type": "", + "value": "0x1cd78c1f748a79cc92e7f09be7271c3ed0cb9011b689f330b27e29c4bd2b3ebd" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "16001:6:0", + "nodeType": "YulIdentifier", + "src": "16001:6:0" + }, + "nativeSrc": "16001:82:0", + "nodeType": "YulFunctionCall", + "src": "16001:82:0" + }, + "nativeSrc": "16001:82:0", + "nodeType": "YulExpressionStatement", + "src": "16001:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "16133:6:0", + "nodeType": "YulLiteral", + "src": "16133:6:0", + "type": "", + "value": "0x0c20" + }, + { + "kind": "number", + "nativeSrc": "16141:66:0", + "nodeType": "YulLiteral", + "src": "16141:66:0", + "type": "", + "value": "0x0727ebd80c29d0cb3506ddd437bb7cbaaa21cd26156bc0b55accc4513990e5db" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "16126:6:0", + "nodeType": "YulIdentifier", + "src": "16126:6:0" + }, + "nativeSrc": "16126:82:0", + "nodeType": "YulFunctionCall", + "src": "16126:82:0" + }, + "nativeSrc": "16126:82:0", + "nodeType": "YulExpressionStatement", + "src": "16126:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "16258:6:0", + "nodeType": "YulLiteral", + "src": "16258:6:0", + "type": "", + "value": "0x0c40" + }, + { + "kind": "number", + "nativeSrc": "16266:66:0", + "nodeType": "YulLiteral", + "src": "16266:66:0", + "type": "", + "value": "0x109dda392f081726a5da7cf48183ff5ee198df6d106388060ef3420679577dad" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "16251:6:0", + "nodeType": "YulIdentifier", + "src": "16251:6:0" + }, + "nativeSrc": "16251:82:0", + "nodeType": "YulFunctionCall", + "src": "16251:82:0" + }, + "nativeSrc": "16251:82:0", + "nodeType": "YulExpressionStatement", + "src": "16251:82:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "16383:6:0", + "nodeType": "YulLiteral", + "src": "16383:6:0", + "type": "", + "value": "0x0c60" + }, + { + "kind": "number", + "nativeSrc": "16391:66:0", + "nodeType": "YulLiteral", + "src": "16391:66:0", + "type": "", + "value": "0x0977289e8061c245ca55a4494006a7c12dca372407c5d8c2b9bf7d7d31c3dbed" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "16376:6:0", + "nodeType": "YulIdentifier", + "src": "16376:6:0" + }, + "nativeSrc": "16376:82:0", + "nodeType": "YulFunctionCall", + "src": "16376:82:0" + }, + "nativeSrc": "16376:82:0", + "nodeType": "YulExpressionStatement", + "src": "16376:82:0" + }, + { + "nativeSrc": "16549:65:0", + "nodeType": "YulAssignment", + "src": "16549:65:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "16564:7:0", + "nodeType": "YulIdentifier", + "src": "16564:7:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "16576:6:0", + "nodeType": "YulLiteral", + "src": "16576:6:0", + "type": "", + "value": "0x0900" + }, + { + "arguments": [ + { + "name": "PROOF_LEN_CPTR", + "nativeSrc": "16597:14:0", + "nodeType": "YulIdentifier", + "src": "16597:14:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "16584:12:0", + "nodeType": "YulIdentifier", + "src": "16584:12:0" + }, + "nativeSrc": "16584:28:0", + "nodeType": "YulFunctionCall", + "src": "16584:28:0" + } + ], + "functionName": { + "name": "eq", + "nativeSrc": "16573:2:0", + "nodeType": "YulIdentifier", + "src": "16573:2:0" + }, + "nativeSrc": "16573:40:0", + "nodeType": "YulFunctionCall", + "src": "16573:40:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "16560:3:0", + "nodeType": "YulIdentifier", + "src": "16560:3:0" + }, + "nativeSrc": "16560:54:0", + "nodeType": "YulFunctionCall", + "src": "16560:54:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "16549:7:0", + "nodeType": "YulIdentifier", + "src": "16549:7:0" + } + ] + }, + { + "nativeSrc": "16683:46:0", + "nodeType": "YulVariableDeclaration", + "src": "16683:46:0", + "value": { + "arguments": [ + { + "name": "NUM_INSTANCES_MPTR", + "nativeSrc": "16710:18:0", + "nodeType": "YulIdentifier", + "src": "16710:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "16704:5:0", + "nodeType": "YulIdentifier", + "src": "16704:5:0" + }, + "nativeSrc": "16704:25:0", + "nodeType": "YulFunctionCall", + "src": "16704:25:0" + }, + "variables": [ + { + "name": "num_instances", + "nativeSrc": "16687:13:0", + "nodeType": "YulTypedName", + "src": "16687:13:0", + "type": "" + } + ] + }, + { + "nativeSrc": "16746:75:0", + "nodeType": "YulAssignment", + "src": "16746:75:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "16761:7:0", + "nodeType": "YulIdentifier", + "src": "16761:7:0" + }, + { + "arguments": [ + { + "name": "num_instances", + "nativeSrc": "16773:13:0", + "nodeType": "YulIdentifier", + "src": "16773:13:0" + }, + { + "arguments": [ + { + "name": "NUM_INSTANCE_CPTR", + "nativeSrc": "16801:17:0", + "nodeType": "YulIdentifier", + "src": "16801:17:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "16788:12:0", + "nodeType": "YulIdentifier", + "src": "16788:12:0" + }, + "nativeSrc": "16788:31:0", + "nodeType": "YulFunctionCall", + "src": "16788:31:0" + } + ], + "functionName": { + "name": "eq", + "nativeSrc": "16770:2:0", + "nodeType": "YulIdentifier", + "src": "16770:2:0" + }, + "nativeSrc": "16770:50:0", + "nodeType": "YulFunctionCall", + "src": "16770:50:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "16757:3:0", + "nodeType": "YulIdentifier", + "src": "16757:3:0" + }, + "nativeSrc": "16757:64:0", + "nodeType": "YulFunctionCall", + "src": "16757:64:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "16746:7:0", + "nodeType": "YulIdentifier", + "src": "16746:7:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "16882:4:0", + "nodeType": "YulLiteral", + "src": "16882:4:0", + "type": "", + "value": "0x00" + }, + { + "arguments": [ + { + "name": "VK_DIGEST_MPTR", + "nativeSrc": "16894:14:0", + "nodeType": "YulIdentifier", + "src": "16894:14:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "16888:5:0", + "nodeType": "YulIdentifier", + "src": "16888:5:0" + }, + "nativeSrc": "16888:21:0", + "nodeType": "YulFunctionCall", + "src": "16888:21:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "16875:6:0", + "nodeType": "YulIdentifier", + "src": "16875:6:0" + }, + "nativeSrc": "16875:35:0", + "nodeType": "YulFunctionCall", + "src": "16875:35:0" + }, + "nativeSrc": "16875:35:0", + "nodeType": "YulExpressionStatement", + "src": "16875:35:0" + }, + { + "nativeSrc": "17010:21:0", + "nodeType": "YulVariableDeclaration", + "src": "17010:21:0", + "value": { + "kind": "number", + "nativeSrc": "17027:4:0", + "nodeType": "YulLiteral", + "src": "17027:4:0", + "type": "", + "value": "0x20" + }, + "variables": [ + { + "name": "hash_mptr", + "nativeSrc": "17014:9:0", + "nodeType": "YulTypedName", + "src": "17014:9:0", + "type": "" + } + ] + }, + { + "nativeSrc": "17048:34:0", + "nodeType": "YulVariableDeclaration", + "src": "17048:34:0", + "value": { + "name": "INSTANCE_CPTR", + "nativeSrc": "17069:13:0", + "nodeType": "YulIdentifier", + "src": "17069:13:0" + }, + "variables": [ + { + "name": "instance_cptr", + "nativeSrc": "17052:13:0", + "nodeType": "YulTypedName", + "src": "17052:13:0", + "type": "" + } + ] + }, + { + "body": { + "nativeSrc": "17293:308:0", + "nodeType": "YulBlock", + "src": "17293:308:0", + "statements": [ + { + "nativeSrc": "17315:43:0", + "nodeType": "YulVariableDeclaration", + "src": "17315:43:0", + "value": { + "arguments": [ + { + "name": "instance_cptr", + "nativeSrc": "17344:13:0", + "nodeType": "YulIdentifier", + "src": "17344:13:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "17331:12:0", + "nodeType": "YulIdentifier", + "src": "17331:12:0" + }, + "nativeSrc": "17331:27:0", + "nodeType": "YulFunctionCall", + "src": "17331:27:0" + }, + "variables": [ + { + "name": "instance", + "nativeSrc": "17319:8:0", + "nodeType": "YulTypedName", + "src": "17319:8:0", + "type": "" + } + ] + }, + { + "nativeSrc": "17379:40:0", + "nodeType": "YulAssignment", + "src": "17379:40:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "17394:7:0", + "nodeType": "YulIdentifier", + "src": "17394:7:0" + }, + { + "arguments": [ + { + "name": "instance", + "nativeSrc": "17406:8:0", + "nodeType": "YulIdentifier", + "src": "17406:8:0" + }, + { + "name": "r", + "nativeSrc": "17416:1:0", + "nodeType": "YulIdentifier", + "src": "17416:1:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "17403:2:0", + "nodeType": "YulIdentifier", + "src": "17403:2:0" + }, + "nativeSrc": "17403:15:0", + "nodeType": "YulFunctionCall", + "src": "17403:15:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "17390:3:0", + "nodeType": "YulIdentifier", + "src": "17390:3:0" + }, + "nativeSrc": "17390:29:0", + "nodeType": "YulFunctionCall", + "src": "17390:29:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "17379:7:0", + "nodeType": "YulIdentifier", + "src": "17379:7:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "hash_mptr", + "nativeSrc": "17447:9:0", + "nodeType": "YulIdentifier", + "src": "17447:9:0" + }, + { + "name": "instance", + "nativeSrc": "17458:8:0", + "nodeType": "YulIdentifier", + "src": "17458:8:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "17440:6:0", + "nodeType": "YulIdentifier", + "src": "17440:6:0" + }, + "nativeSrc": "17440:27:0", + "nodeType": "YulFunctionCall", + "src": "17440:27:0" + }, + "nativeSrc": "17440:27:0", + "nodeType": "YulExpressionStatement", + "src": "17440:27:0" + }, + { + "nativeSrc": "17488:41:0", + "nodeType": "YulAssignment", + "src": "17488:41:0", + "value": { + "arguments": [ + { + "name": "instance_cptr", + "nativeSrc": "17509:13:0", + "nodeType": "YulIdentifier", + "src": "17509:13:0" + }, + { + "kind": "number", + "nativeSrc": "17524:4:0", + "nodeType": "YulLiteral", + "src": "17524:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "17505:3:0", + "nodeType": "YulIdentifier", + "src": "17505:3:0" + }, + "nativeSrc": "17505:24:0", + "nodeType": "YulFunctionCall", + "src": "17505:24:0" + }, + "variableNames": [ + { + "name": "instance_cptr", + "nativeSrc": "17488:13:0", + "nodeType": "YulIdentifier", + "src": "17488:13:0" + } + ] + }, + { + "nativeSrc": "17550:33:0", + "nodeType": "YulAssignment", + "src": "17550:33:0", + "value": { + "arguments": [ + { + "name": "hash_mptr", + "nativeSrc": "17567:9:0", + "nodeType": "YulIdentifier", + "src": "17567:9:0" + }, + { + "kind": "number", + "nativeSrc": "17578:4:0", + "nodeType": "YulLiteral", + "src": "17578:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "17563:3:0", + "nodeType": "YulIdentifier", + "src": "17563:3:0" + }, + "nativeSrc": "17563:20:0", + "nodeType": "YulFunctionCall", + "src": "17563:20:0" + }, + "variableNames": [ + { + "name": "hash_mptr", + "nativeSrc": "17550:9:0", + "nodeType": "YulIdentifier", + "src": "17550:9:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "instance_cptr", + "nativeSrc": "17220:13:0", + "nodeType": "YulIdentifier", + "src": "17220:13:0" + }, + { + "name": "instance_cptr_end", + "nativeSrc": "17235:17:0", + "nodeType": "YulIdentifier", + "src": "17235:17:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "17217:2:0", + "nodeType": "YulIdentifier", + "src": "17217:2:0" + }, + "nativeSrc": "17217:36:0", + "nodeType": "YulFunctionCall", + "src": "17217:36:0" + }, + "nativeSrc": "17099:502:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "17274:2:0", + "nodeType": "YulBlock", + "src": "17274:2:0", + "statements": [] + }, + "pre": { + "nativeSrc": "17123:73:0", + "nodeType": "YulBlock", + "src": "17123:73:0", + "statements": [ + { + "nativeSrc": "17125:69:0", + "nodeType": "YulVariableDeclaration", + "src": "17125:69:0", + "value": { + "arguments": [ + { + "name": "instance_cptr", + "nativeSrc": "17154:13:0", + "nodeType": "YulIdentifier", + "src": "17154:13:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "17173:4:0", + "nodeType": "YulLiteral", + "src": "17173:4:0", + "type": "", + "value": "0x20" + }, + { + "name": "num_instances", + "nativeSrc": "17179:13:0", + "nodeType": "YulIdentifier", + "src": "17179:13:0" + } + ], + "functionName": { + "name": "mul", + "nativeSrc": "17169:3:0", + "nodeType": "YulIdentifier", + "src": "17169:3:0" + }, + "nativeSrc": "17169:24:0", + "nodeType": "YulFunctionCall", + "src": "17169:24:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "17150:3:0", + "nodeType": "YulIdentifier", + "src": "17150:3:0" + }, + "nativeSrc": "17150:44:0", + "nodeType": "YulFunctionCall", + "src": "17150:44:0" + }, + "variables": [ + { + "name": "instance_cptr_end", + "nativeSrc": "17129:17:0", + "nodeType": "YulTypedName", + "src": "17129:17:0", + "type": "" + } + ] + } + ] + }, + "src": "17099:502:0" + }, + { + "nativeSrc": "17619:28:0", + "nodeType": "YulVariableDeclaration", + "src": "17619:28:0", + "value": { + "name": "PROOF_CPTR", + "nativeSrc": "17637:10:0", + "nodeType": "YulIdentifier", + "src": "17637:10:0" + }, + "variables": [ + { + "name": "proof_cptr", + "nativeSrc": "17623:10:0", + "nodeType": "YulTypedName", + "src": "17623:10:0", + "type": "" + } + ] + }, + { + "nativeSrc": "17664:36:0", + "nodeType": "YulVariableDeclaration", + "src": "17664:36:0", + "value": { + "name": "CHALLENGE_MPTR", + "nativeSrc": "17686:14:0", + "nodeType": "YulIdentifier", + "src": "17686:14:0" + }, + "variables": [ + { + "name": "challenge_mptr", + "nativeSrc": "17668:14:0", + "nodeType": "YulTypedName", + "src": "17668:14:0", + "type": "" + } + ] + }, + { + "body": { + "nativeSrc": "17907:122:0", + "nodeType": "YulBlock", + "src": "17907:122:0", + "statements": [ + { + "nativeSrc": "17929:82:0", + "nodeType": "YulAssignment", + "src": "17929:82:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "17977:7:0", + "nodeType": "YulIdentifier", + "src": "17977:7:0" + }, + { + "name": "proof_cptr", + "nativeSrc": "17986:10:0", + "nodeType": "YulIdentifier", + "src": "17986:10:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "17998:9:0", + "nodeType": "YulIdentifier", + "src": "17998:9:0" + }, + { + "name": "q", + "nativeSrc": "18009:1:0", + "nodeType": "YulIdentifier", + "src": "18009:1:0" + } + ], + "functionName": { + "name": "read_ec_point", + "nativeSrc": "17963:13:0", + "nodeType": "YulIdentifier", + "src": "17963:13:0" + }, + "nativeSrc": "17963:48:0", + "nodeType": "YulFunctionCall", + "src": "17963:48:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "17929:7:0", + "nodeType": "YulIdentifier", + "src": "17929:7:0" + }, + { + "name": "proof_cptr", + "nativeSrc": "17938:10:0", + "nodeType": "YulIdentifier", + "src": "17938:10:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "17950:9:0", + "nodeType": "YulIdentifier", + "src": "17950:9:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "17840:10:0", + "nodeType": "YulIdentifier", + "src": "17840:10:0" + }, + { + "name": "proof_cptr_end", + "nativeSrc": "17852:14:0", + "nodeType": "YulIdentifier", + "src": "17852:14:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "17837:2:0", + "nodeType": "YulIdentifier", + "src": "17837:2:0" + }, + "nativeSrc": "17837:30:0", + "nodeType": "YulFunctionCall", + "src": "17837:30:0" + }, + "nativeSrc": "17745:284:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "17888:2:0", + "nodeType": "YulBlock", + "src": "17888:2:0", + "statements": [] + }, + "pre": { + "nativeSrc": "17769:47:0", + "nodeType": "YulBlock", + "src": "17769:47:0", + "statements": [ + { + "nativeSrc": "17771:43:0", + "nodeType": "YulVariableDeclaration", + "src": "17771:43:0", + "value": { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "17797:10:0", + "nodeType": "YulIdentifier", + "src": "17797:10:0" + }, + { + "kind": "number", + "nativeSrc": "17809:4:0", + "nodeType": "YulLiteral", + "src": "17809:4:0", + "type": "", + "value": "0xc0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "17793:3:0", + "nodeType": "YulIdentifier", + "src": "17793:3:0" + }, + "nativeSrc": "17793:21:0", + "nodeType": "YulFunctionCall", + "src": "17793:21:0" + }, + "variables": [ + { + "name": "proof_cptr_end", + "nativeSrc": "17775:14:0", + "nodeType": "YulTypedName", + "src": "17775:14:0", + "type": "" + } + ] + } + ] + }, + "src": "17745:284:0" + }, + { + "nativeSrc": "18047:76:0", + "nodeType": "YulAssignment", + "src": "18047:76:0", + "value": { + "arguments": [ + { + "name": "challenge_mptr", + "nativeSrc": "18094:14:0", + "nodeType": "YulIdentifier", + "src": "18094:14:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "18110:9:0", + "nodeType": "YulIdentifier", + "src": "18110:9:0" + }, + { + "name": "r", + "nativeSrc": "18121:1:0", + "nodeType": "YulIdentifier", + "src": "18121:1:0" + } + ], + "functionName": { + "name": "squeeze_challenge", + "nativeSrc": "18076:17:0", + "nodeType": "YulIdentifier", + "src": "18076:17:0" + }, + "nativeSrc": "18076:47:0", + "nodeType": "YulFunctionCall", + "src": "18076:47:0" + }, + "variableNames": [ + { + "name": "challenge_mptr", + "nativeSrc": "18047:14:0", + "nodeType": "YulIdentifier", + "src": "18047:14:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "18063:9:0", + "nodeType": "YulIdentifier", + "src": "18063:9:0" + } + ] + }, + { + "body": { + "nativeSrc": "18330:122:0", + "nodeType": "YulBlock", + "src": "18330:122:0", + "statements": [ + { + "nativeSrc": "18352:82:0", + "nodeType": "YulAssignment", + "src": "18352:82:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "18400:7:0", + "nodeType": "YulIdentifier", + "src": "18400:7:0" + }, + { + "name": "proof_cptr", + "nativeSrc": "18409:10:0", + "nodeType": "YulIdentifier", + "src": "18409:10:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "18421:9:0", + "nodeType": "YulIdentifier", + "src": "18421:9:0" + }, + { + "name": "q", + "nativeSrc": "18432:1:0", + "nodeType": "YulIdentifier", + "src": "18432:1:0" + } + ], + "functionName": { + "name": "read_ec_point", + "nativeSrc": "18386:13:0", + "nodeType": "YulIdentifier", + "src": "18386:13:0" + }, + "nativeSrc": "18386:48:0", + "nodeType": "YulFunctionCall", + "src": "18386:48:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "18352:7:0", + "nodeType": "YulIdentifier", + "src": "18352:7:0" + }, + { + "name": "proof_cptr", + "nativeSrc": "18361:10:0", + "nodeType": "YulIdentifier", + "src": "18361:10:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "18373:9:0", + "nodeType": "YulIdentifier", + "src": "18373:9:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "18263:10:0", + "nodeType": "YulIdentifier", + "src": "18263:10:0" + }, + { + "name": "proof_cptr_end", + "nativeSrc": "18275:14:0", + "nodeType": "YulIdentifier", + "src": "18275:14:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "18260:2:0", + "nodeType": "YulIdentifier", + "src": "18260:2:0" + }, + "nativeSrc": "18260:30:0", + "nodeType": "YulFunctionCall", + "src": "18260:30:0" + }, + "nativeSrc": "18168:284:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "18311:2:0", + "nodeType": "YulBlock", + "src": "18311:2:0", + "statements": [] + }, + "pre": { + "nativeSrc": "18192:47:0", + "nodeType": "YulBlock", + "src": "18192:47:0", + "statements": [ + { + "nativeSrc": "18194:43:0", + "nodeType": "YulVariableDeclaration", + "src": "18194:43:0", + "value": { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "18220:10:0", + "nodeType": "YulIdentifier", + "src": "18220:10:0" + }, + { + "kind": "number", + "nativeSrc": "18232:4:0", + "nodeType": "YulLiteral", + "src": "18232:4:0", + "type": "", + "value": "0xc0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "18216:3:0", + "nodeType": "YulIdentifier", + "src": "18216:3:0" + }, + "nativeSrc": "18216:21:0", + "nodeType": "YulFunctionCall", + "src": "18216:21:0" + }, + "variables": [ + { + "name": "proof_cptr_end", + "nativeSrc": "18198:14:0", + "nodeType": "YulTypedName", + "src": "18198:14:0", + "type": "" + } + ] + } + ] + }, + "src": "18168:284:0" + }, + { + "nativeSrc": "18470:76:0", + "nodeType": "YulAssignment", + "src": "18470:76:0", + "value": { + "arguments": [ + { + "name": "challenge_mptr", + "nativeSrc": "18517:14:0", + "nodeType": "YulIdentifier", + "src": "18517:14:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "18533:9:0", + "nodeType": "YulIdentifier", + "src": "18533:9:0" + }, + { + "name": "r", + "nativeSrc": "18544:1:0", + "nodeType": "YulIdentifier", + "src": "18544:1:0" + } + ], + "functionName": { + "name": "squeeze_challenge", + "nativeSrc": "18499:17:0", + "nodeType": "YulIdentifier", + "src": "18499:17:0" + }, + "nativeSrc": "18499:47:0", + "nodeType": "YulFunctionCall", + "src": "18499:47:0" + }, + "variableNames": [ + { + "name": "challenge_mptr", + "nativeSrc": "18470:14:0", + "nodeType": "YulIdentifier", + "src": "18470:14:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "18486:9:0", + "nodeType": "YulIdentifier", + "src": "18486:9:0" + } + ] + }, + { + "nativeSrc": "18563:59:0", + "nodeType": "YulAssignment", + "src": "18563:59:0", + "value": { + "arguments": [ + { + "name": "challenge_mptr", + "nativeSrc": "18604:14:0", + "nodeType": "YulIdentifier", + "src": "18604:14:0" + }, + { + "name": "r", + "nativeSrc": "18620:1:0", + "nodeType": "YulIdentifier", + "src": "18620:1:0" + } + ], + "functionName": { + "name": "squeeze_challenge_cont", + "nativeSrc": "18581:22:0", + "nodeType": "YulIdentifier", + "src": "18581:22:0" + }, + "nativeSrc": "18581:41:0", + "nodeType": "YulFunctionCall", + "src": "18581:41:0" + }, + "variableNames": [ + { + "name": "challenge_mptr", + "nativeSrc": "18563:14:0", + "nodeType": "YulIdentifier", + "src": "18563:14:0" + } + ] + }, + { + "body": { + "nativeSrc": "18831:122:0", + "nodeType": "YulBlock", + "src": "18831:122:0", + "statements": [ + { + "nativeSrc": "18853:82:0", + "nodeType": "YulAssignment", + "src": "18853:82:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "18901:7:0", + "nodeType": "YulIdentifier", + "src": "18901:7:0" + }, + { + "name": "proof_cptr", + "nativeSrc": "18910:10:0", + "nodeType": "YulIdentifier", + "src": "18910:10:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "18922:9:0", + "nodeType": "YulIdentifier", + "src": "18922:9:0" + }, + { + "name": "q", + "nativeSrc": "18933:1:0", + "nodeType": "YulIdentifier", + "src": "18933:1:0" + } + ], + "functionName": { + "name": "read_ec_point", + "nativeSrc": "18887:13:0", + "nodeType": "YulIdentifier", + "src": "18887:13:0" + }, + "nativeSrc": "18887:48:0", + "nodeType": "YulFunctionCall", + "src": "18887:48:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "18853:7:0", + "nodeType": "YulIdentifier", + "src": "18853:7:0" + }, + { + "name": "proof_cptr", + "nativeSrc": "18862:10:0", + "nodeType": "YulIdentifier", + "src": "18862:10:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "18874:9:0", + "nodeType": "YulIdentifier", + "src": "18874:9:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "18764:10:0", + "nodeType": "YulIdentifier", + "src": "18764:10:0" + }, + { + "name": "proof_cptr_end", + "nativeSrc": "18776:14:0", + "nodeType": "YulIdentifier", + "src": "18776:14:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "18761:2:0", + "nodeType": "YulIdentifier", + "src": "18761:2:0" + }, + "nativeSrc": "18761:30:0", + "nodeType": "YulFunctionCall", + "src": "18761:30:0" + }, + "nativeSrc": "18667:286:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "18812:2:0", + "nodeType": "YulBlock", + "src": "18812:2:0", + "statements": [] + }, + "pre": { + "nativeSrc": "18691:49:0", + "nodeType": "YulBlock", + "src": "18691:49:0", + "statements": [ + { + "nativeSrc": "18693:45:0", + "nodeType": "YulVariableDeclaration", + "src": "18693:45:0", + "value": { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "18719:10:0", + "nodeType": "YulIdentifier", + "src": "18719:10:0" + }, + { + "kind": "number", + "nativeSrc": "18731:6:0", + "nodeType": "YulLiteral", + "src": "18731:6:0", + "type": "", + "value": "0x0180" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "18715:3:0", + "nodeType": "YulIdentifier", + "src": "18715:3:0" + }, + "nativeSrc": "18715:23:0", + "nodeType": "YulFunctionCall", + "src": "18715:23:0" + }, + "variables": [ + { + "name": "proof_cptr_end", + "nativeSrc": "18697:14:0", + "nodeType": "YulTypedName", + "src": "18697:14:0", + "type": "" + } + ] + } + ] + }, + "src": "18667:286:0" + }, + { + "nativeSrc": "18971:76:0", + "nodeType": "YulAssignment", + "src": "18971:76:0", + "value": { + "arguments": [ + { + "name": "challenge_mptr", + "nativeSrc": "19018:14:0", + "nodeType": "YulIdentifier", + "src": "19018:14:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "19034:9:0", + "nodeType": "YulIdentifier", + "src": "19034:9:0" + }, + { + "name": "r", + "nativeSrc": "19045:1:0", + "nodeType": "YulIdentifier", + "src": "19045:1:0" + } + ], + "functionName": { + "name": "squeeze_challenge", + "nativeSrc": "19000:17:0", + "nodeType": "YulIdentifier", + "src": "19000:17:0" + }, + "nativeSrc": "19000:47:0", + "nodeType": "YulFunctionCall", + "src": "19000:47:0" + }, + "variableNames": [ + { + "name": "challenge_mptr", + "nativeSrc": "18971:14:0", + "nodeType": "YulIdentifier", + "src": "18971:14:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "18987:9:0", + "nodeType": "YulIdentifier", + "src": "18987:9:0" + } + ] + }, + { + "body": { + "nativeSrc": "19256:122:0", + "nodeType": "YulBlock", + "src": "19256:122:0", + "statements": [ + { + "nativeSrc": "19278:82:0", + "nodeType": "YulAssignment", + "src": "19278:82:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "19326:7:0", + "nodeType": "YulIdentifier", + "src": "19326:7:0" + }, + { + "name": "proof_cptr", + "nativeSrc": "19335:10:0", + "nodeType": "YulIdentifier", + "src": "19335:10:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "19347:9:0", + "nodeType": "YulIdentifier", + "src": "19347:9:0" + }, + { + "name": "q", + "nativeSrc": "19358:1:0", + "nodeType": "YulIdentifier", + "src": "19358:1:0" + } + ], + "functionName": { + "name": "read_ec_point", + "nativeSrc": "19312:13:0", + "nodeType": "YulIdentifier", + "src": "19312:13:0" + }, + "nativeSrc": "19312:48:0", + "nodeType": "YulFunctionCall", + "src": "19312:48:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "19278:7:0", + "nodeType": "YulIdentifier", + "src": "19278:7:0" + }, + { + "name": "proof_cptr", + "nativeSrc": "19287:10:0", + "nodeType": "YulIdentifier", + "src": "19287:10:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "19299:9:0", + "nodeType": "YulIdentifier", + "src": "19299:9:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "19189:10:0", + "nodeType": "YulIdentifier", + "src": "19189:10:0" + }, + { + "name": "proof_cptr_end", + "nativeSrc": "19201:14:0", + "nodeType": "YulIdentifier", + "src": "19201:14:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "19186:2:0", + "nodeType": "YulIdentifier", + "src": "19186:2:0" + }, + "nativeSrc": "19186:30:0", + "nodeType": "YulFunctionCall", + "src": "19186:30:0" + }, + "nativeSrc": "19092:286:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "19237:2:0", + "nodeType": "YulBlock", + "src": "19237:2:0", + "statements": [] + }, + "pre": { + "nativeSrc": "19116:49:0", + "nodeType": "YulBlock", + "src": "19116:49:0", + "statements": [ + { + "nativeSrc": "19118:45:0", + "nodeType": "YulVariableDeclaration", + "src": "19118:45:0", + "value": { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "19144:10:0", + "nodeType": "YulIdentifier", + "src": "19144:10:0" + }, + { + "kind": "number", + "nativeSrc": "19156:6:0", + "nodeType": "YulLiteral", + "src": "19156:6:0", + "type": "", + "value": "0x0100" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "19140:3:0", + "nodeType": "YulIdentifier", + "src": "19140:3:0" + }, + "nativeSrc": "19140:23:0", + "nodeType": "YulFunctionCall", + "src": "19140:23:0" + }, + "variables": [ + { + "name": "proof_cptr_end", + "nativeSrc": "19122:14:0", + "nodeType": "YulTypedName", + "src": "19122:14:0", + "type": "" + } + ] + } + ] + }, + "src": "19092:286:0" + }, + { + "nativeSrc": "19396:76:0", + "nodeType": "YulAssignment", + "src": "19396:76:0", + "value": { + "arguments": [ + { + "name": "challenge_mptr", + "nativeSrc": "19443:14:0", + "nodeType": "YulIdentifier", + "src": "19443:14:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "19459:9:0", + "nodeType": "YulIdentifier", + "src": "19459:9:0" + }, + { + "name": "r", + "nativeSrc": "19470:1:0", + "nodeType": "YulIdentifier", + "src": "19470:1:0" + } + ], + "functionName": { + "name": "squeeze_challenge", + "nativeSrc": "19425:17:0", + "nodeType": "YulIdentifier", + "src": "19425:17:0" + }, + "nativeSrc": "19425:47:0", + "nodeType": "YulFunctionCall", + "src": "19425:47:0" + }, + "variableNames": [ + { + "name": "challenge_mptr", + "nativeSrc": "19396:14:0", + "nodeType": "YulIdentifier", + "src": "19396:14:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "19412:9:0", + "nodeType": "YulIdentifier", + "src": "19412:9:0" + } + ] + }, + { + "body": { + "nativeSrc": "19690:287:0", + "nodeType": "YulBlock", + "src": "19690:287:0", + "statements": [ + { + "nativeSrc": "19712:36:0", + "nodeType": "YulVariableDeclaration", + "src": "19712:36:0", + "value": { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "19737:10:0", + "nodeType": "YulIdentifier", + "src": "19737:10:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "19724:12:0", + "nodeType": "YulIdentifier", + "src": "19724:12:0" + }, + "nativeSrc": "19724:24:0", + "nodeType": "YulFunctionCall", + "src": "19724:24:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "19716:4:0", + "nodeType": "YulTypedName", + "src": "19716:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "19769:36:0", + "nodeType": "YulAssignment", + "src": "19769:36:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "19784:7:0", + "nodeType": "YulIdentifier", + "src": "19784:7:0" + }, + { + "arguments": [ + { + "name": "eval", + "nativeSrc": "19796:4:0", + "nodeType": "YulIdentifier", + "src": "19796:4:0" + }, + { + "name": "r", + "nativeSrc": "19802:1:0", + "nodeType": "YulIdentifier", + "src": "19802:1:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "19793:2:0", + "nodeType": "YulIdentifier", + "src": "19793:2:0" + }, + "nativeSrc": "19793:11:0", + "nodeType": "YulFunctionCall", + "src": "19793:11:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "19780:3:0", + "nodeType": "YulIdentifier", + "src": "19780:3:0" + }, + "nativeSrc": "19780:25:0", + "nodeType": "YulFunctionCall", + "src": "19780:25:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "19769:7:0", + "nodeType": "YulIdentifier", + "src": "19769:7:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "hash_mptr", + "nativeSrc": "19833:9:0", + "nodeType": "YulIdentifier", + "src": "19833:9:0" + }, + { + "name": "eval", + "nativeSrc": "19844:4:0", + "nodeType": "YulIdentifier", + "src": "19844:4:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "19826:6:0", + "nodeType": "YulIdentifier", + "src": "19826:6:0" + }, + "nativeSrc": "19826:23:0", + "nodeType": "YulFunctionCall", + "src": "19826:23:0" + }, + "nativeSrc": "19826:23:0", + "nodeType": "YulExpressionStatement", + "src": "19826:23:0" + }, + { + "nativeSrc": "19870:35:0", + "nodeType": "YulAssignment", + "src": "19870:35:0", + "value": { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "19888:10:0", + "nodeType": "YulIdentifier", + "src": "19888:10:0" + }, + { + "kind": "number", + "nativeSrc": "19900:4:0", + "nodeType": "YulLiteral", + "src": "19900:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "19884:3:0", + "nodeType": "YulIdentifier", + "src": "19884:3:0" + }, + "nativeSrc": "19884:21:0", + "nodeType": "YulFunctionCall", + "src": "19884:21:0" + }, + "variableNames": [ + { + "name": "proof_cptr", + "nativeSrc": "19870:10:0", + "nodeType": "YulIdentifier", + "src": "19870:10:0" + } + ] + }, + { + "nativeSrc": "19926:33:0", + "nodeType": "YulAssignment", + "src": "19926:33:0", + "value": { + "arguments": [ + { + "name": "hash_mptr", + "nativeSrc": "19943:9:0", + "nodeType": "YulIdentifier", + "src": "19943:9:0" + }, + { + "kind": "number", + "nativeSrc": "19954:4:0", + "nodeType": "YulLiteral", + "src": "19954:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "19939:3:0", + "nodeType": "YulIdentifier", + "src": "19939:3:0" + }, + "nativeSrc": "19939:20:0", + "nodeType": "YulFunctionCall", + "src": "19939:20:0" + }, + "variableNames": [ + { + "name": "hash_mptr", + "nativeSrc": "19926:9:0", + "nodeType": "YulIdentifier", + "src": "19926:9:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "19623:10:0", + "nodeType": "YulIdentifier", + "src": "19623:10:0" + }, + { + "name": "proof_cptr_end", + "nativeSrc": "19635:14:0", + "nodeType": "YulIdentifier", + "src": "19635:14:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "19620:2:0", + "nodeType": "YulIdentifier", + "src": "19620:2:0" + }, + "nativeSrc": "19620:30:0", + "nodeType": "YulFunctionCall", + "src": "19620:30:0" + }, + "nativeSrc": "19526:451:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "19671:2:0", + "nodeType": "YulBlock", + "src": "19671:2:0", + "statements": [] + }, + "pre": { + "nativeSrc": "19550:49:0", + "nodeType": "YulBlock", + "src": "19550:49:0", + "statements": [ + { + "nativeSrc": "19552:45:0", + "nodeType": "YulVariableDeclaration", + "src": "19552:45:0", + "value": { + "arguments": [ + { + "name": "proof_cptr", + "nativeSrc": "19578:10:0", + "nodeType": "YulIdentifier", + "src": "19578:10:0" + }, + { + "kind": "number", + "nativeSrc": "19590:6:0", + "nodeType": "YulLiteral", + "src": "19590:6:0", + "type": "", + "value": "0x0480" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "19574:3:0", + "nodeType": "YulIdentifier", + "src": "19574:3:0" + }, + "nativeSrc": "19574:23:0", + "nodeType": "YulFunctionCall", + "src": "19574:23:0" + }, + "variables": [ + { + "name": "proof_cptr_end", + "nativeSrc": "19556:14:0", + "nodeType": "YulTypedName", + "src": "19556:14:0", + "type": "" + } + ] + } + ] + }, + "src": "19526:451:0" + }, + { + "nativeSrc": "20063:76:0", + "nodeType": "YulAssignment", + "src": "20063:76:0", + "value": { + "arguments": [ + { + "name": "challenge_mptr", + "nativeSrc": "20110:14:0", + "nodeType": "YulIdentifier", + "src": "20110:14:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "20126:9:0", + "nodeType": "YulIdentifier", + "src": "20126:9:0" + }, + { + "name": "r", + "nativeSrc": "20137:1:0", + "nodeType": "YulIdentifier", + "src": "20137:1:0" + } + ], + "functionName": { + "name": "squeeze_challenge", + "nativeSrc": "20092:17:0", + "nodeType": "YulIdentifier", + "src": "20092:17:0" + }, + "nativeSrc": "20092:47:0", + "nodeType": "YulFunctionCall", + "src": "20092:47:0" + }, + "variableNames": [ + { + "name": "challenge_mptr", + "nativeSrc": "20063:14:0", + "nodeType": "YulIdentifier", + "src": "20063:14:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "20079:9:0", + "nodeType": "YulIdentifier", + "src": "20079:9:0" + } + ] + }, + { + "nativeSrc": "20170:59:0", + "nodeType": "YulAssignment", + "src": "20170:59:0", + "value": { + "arguments": [ + { + "name": "challenge_mptr", + "nativeSrc": "20211:14:0", + "nodeType": "YulIdentifier", + "src": "20211:14:0" + }, + { + "name": "r", + "nativeSrc": "20227:1:0", + "nodeType": "YulIdentifier", + "src": "20227:1:0" + } + ], + "functionName": { + "name": "squeeze_challenge_cont", + "nativeSrc": "20188:22:0", + "nodeType": "YulIdentifier", + "src": "20188:22:0" + }, + "nativeSrc": "20188:41:0", + "nodeType": "YulFunctionCall", + "src": "20188:41:0" + }, + "variableNames": [ + { + "name": "challenge_mptr", + "nativeSrc": "20170:14:0", + "nodeType": "YulIdentifier", + "src": "20170:14:0" + } + ] + }, + { + "nativeSrc": "20276:82:0", + "nodeType": "YulAssignment", + "src": "20276:82:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "20324:7:0", + "nodeType": "YulIdentifier", + "src": "20324:7:0" + }, + { + "name": "proof_cptr", + "nativeSrc": "20333:10:0", + "nodeType": "YulIdentifier", + "src": "20333:10:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "20345:9:0", + "nodeType": "YulIdentifier", + "src": "20345:9:0" + }, + { + "name": "q", + "nativeSrc": "20356:1:0", + "nodeType": "YulIdentifier", + "src": "20356:1:0" + } + ], + "functionName": { + "name": "read_ec_point", + "nativeSrc": "20310:13:0", + "nodeType": "YulIdentifier", + "src": "20310:13:0" + }, + "nativeSrc": "20310:48:0", + "nodeType": "YulFunctionCall", + "src": "20310:48:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "20276:7:0", + "nodeType": "YulIdentifier", + "src": "20276:7:0" + }, + { + "name": "proof_cptr", + "nativeSrc": "20285:10:0", + "nodeType": "YulIdentifier", + "src": "20285:10:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "20297:9:0", + "nodeType": "YulIdentifier", + "src": "20297:9:0" + } + ] + }, + { + "nativeSrc": "20381:76:0", + "nodeType": "YulAssignment", + "src": "20381:76:0", + "value": { + "arguments": [ + { + "name": "challenge_mptr", + "nativeSrc": "20428:14:0", + "nodeType": "YulIdentifier", + "src": "20428:14:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "20444:9:0", + "nodeType": "YulIdentifier", + "src": "20444:9:0" + }, + { + "name": "r", + "nativeSrc": "20455:1:0", + "nodeType": "YulIdentifier", + "src": "20455:1:0" + } + ], + "functionName": { + "name": "squeeze_challenge", + "nativeSrc": "20410:17:0", + "nodeType": "YulIdentifier", + "src": "20410:17:0" + }, + "nativeSrc": "20410:47:0", + "nodeType": "YulFunctionCall", + "src": "20410:47:0" + }, + "variableNames": [ + { + "name": "challenge_mptr", + "nativeSrc": "20381:14:0", + "nodeType": "YulIdentifier", + "src": "20381:14:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "20397:9:0", + "nodeType": "YulIdentifier", + "src": "20397:9:0" + } + ] + }, + { + "nativeSrc": "20487:82:0", + "nodeType": "YulAssignment", + "src": "20487:82:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "20535:7:0", + "nodeType": "YulIdentifier", + "src": "20535:7:0" + }, + { + "name": "proof_cptr", + "nativeSrc": "20544:10:0", + "nodeType": "YulIdentifier", + "src": "20544:10:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "20556:9:0", + "nodeType": "YulIdentifier", + "src": "20556:9:0" + }, + { + "name": "q", + "nativeSrc": "20567:1:0", + "nodeType": "YulIdentifier", + "src": "20567:1:0" + } + ], + "functionName": { + "name": "read_ec_point", + "nativeSrc": "20521:13:0", + "nodeType": "YulIdentifier", + "src": "20521:13:0" + }, + "nativeSrc": "20521:48:0", + "nodeType": "YulFunctionCall", + "src": "20521:48:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "20487:7:0", + "nodeType": "YulIdentifier", + "src": "20487:7:0" + }, + { + "name": "proof_cptr", + "nativeSrc": "20496:10:0", + "nodeType": "YulIdentifier", + "src": "20496:10:0" + }, + { + "name": "hash_mptr", + "nativeSrc": "20508:9:0", + "nodeType": "YulIdentifier", + "src": "20508:9:0" + } + ] + }, + { + "body": { + "nativeSrc": "20675:1906:0", + "nodeType": "YulBlock", + "src": "20675:1906:0", + "statements": [ + { + "nativeSrc": "20697:42:0", + "nodeType": "YulVariableDeclaration", + "src": "20697:42:0", + "value": { + "arguments": [ + { + "name": "NUM_ACC_LIMBS_MPTR", + "nativeSrc": "20720:18:0", + "nodeType": "YulIdentifier", + "src": "20720:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "20714:5:0", + "nodeType": "YulIdentifier", + "src": "20714:5:0" + }, + "nativeSrc": "20714:25:0", + "nodeType": "YulFunctionCall", + "src": "20714:25:0" + }, + "variables": [ + { + "name": "num_limbs", + "nativeSrc": "20701:9:0", + "nodeType": "YulTypedName", + "src": "20701:9:0", + "type": "" + } + ] + }, + { + "nativeSrc": "20760:50:0", + "nodeType": "YulVariableDeclaration", + "src": "20760:50:0", + "value": { + "arguments": [ + { + "name": "NUM_ACC_LIMB_BITS_MPTR", + "nativeSrc": "20787:22:0", + "nodeType": "YulIdentifier", + "src": "20787:22:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "20781:5:0", + "nodeType": "YulIdentifier", + "src": "20781:5:0" + }, + "nativeSrc": "20781:29:0", + "nodeType": "YulFunctionCall", + "src": "20781:29:0" + }, + "variables": [ + { + "name": "num_limb_bits", + "nativeSrc": "20764:13:0", + "nodeType": "YulTypedName", + "src": "20764:13:0", + "type": "" + } + ] + }, + { + "nativeSrc": "20832:65:0", + "nodeType": "YulVariableDeclaration", + "src": "20832:65:0", + "value": { + "arguments": [ + { + "name": "INSTANCE_CPTR", + "nativeSrc": "20848:13:0", + "nodeType": "YulIdentifier", + "src": "20848:13:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "ACC_OFFSET_MPTR", + "nativeSrc": "20873:15:0", + "nodeType": "YulIdentifier", + "src": "20873:15:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "20867:5:0", + "nodeType": "YulIdentifier", + "src": "20867:5:0" + }, + "nativeSrc": "20867:22:0", + "nodeType": "YulFunctionCall", + "src": "20867:22:0" + }, + { + "kind": "number", + "nativeSrc": "20891:4:0", + "nodeType": "YulLiteral", + "src": "20891:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "mul", + "nativeSrc": "20863:3:0", + "nodeType": "YulIdentifier", + "src": "20863:3:0" + }, + "nativeSrc": "20863:33:0", + "nodeType": "YulFunctionCall", + "src": "20863:33:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "20844:3:0", + "nodeType": "YulIdentifier", + "src": "20844:3:0" + }, + "nativeSrc": "20844:53:0", + "nodeType": "YulFunctionCall", + "src": "20844:53:0" + }, + "variables": [ + { + "name": "cptr", + "nativeSrc": "20836:4:0", + "nodeType": "YulTypedName", + "src": "20836:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "20918:37:0", + "nodeType": "YulVariableDeclaration", + "src": "20918:37:0", + "value": { + "arguments": [ + { + "name": "num_limbs", + "nativeSrc": "20939:9:0", + "nodeType": "YulIdentifier", + "src": "20939:9:0" + }, + { + "kind": "number", + "nativeSrc": "20950:4:0", + "nodeType": "YulLiteral", + "src": "20950:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "mul", + "nativeSrc": "20935:3:0", + "nodeType": "YulIdentifier", + "src": "20935:3:0" + }, + "nativeSrc": "20935:20:0", + "nodeType": "YulFunctionCall", + "src": "20935:20:0" + }, + "variables": [ + { + "name": "lhs_y_off", + "nativeSrc": "20922:9:0", + "nodeType": "YulTypedName", + "src": "20922:9:0", + "type": "" + } + ] + }, + { + "nativeSrc": "20976:34:0", + "nodeType": "YulVariableDeclaration", + "src": "20976:34:0", + "value": { + "arguments": [ + { + "name": "lhs_y_off", + "nativeSrc": "20997:9:0", + "nodeType": "YulIdentifier", + "src": "20997:9:0" + }, + { + "kind": "number", + "nativeSrc": "21008:1:0", + "nodeType": "YulLiteral", + "src": "21008:1:0", + "type": "", + "value": "2" + } + ], + "functionName": { + "name": "mul", + "nativeSrc": "20993:3:0", + "nodeType": "YulIdentifier", + "src": "20993:3:0" + }, + "nativeSrc": "20993:17:0", + "nodeType": "YulFunctionCall", + "src": "20993:17:0" + }, + "variables": [ + { + "name": "rhs_x_off", + "nativeSrc": "20980:9:0", + "nodeType": "YulTypedName", + "src": "20980:9:0", + "type": "" + } + ] + }, + { + "nativeSrc": "21031:34:0", + "nodeType": "YulVariableDeclaration", + "src": "21031:34:0", + "value": { + "arguments": [ + { + "name": "lhs_y_off", + "nativeSrc": "21052:9:0", + "nodeType": "YulIdentifier", + "src": "21052:9:0" + }, + { + "kind": "number", + "nativeSrc": "21063:1:0", + "nodeType": "YulLiteral", + "src": "21063:1:0", + "type": "", + "value": "3" + } + ], + "functionName": { + "name": "mul", + "nativeSrc": "21048:3:0", + "nodeType": "YulIdentifier", + "src": "21048:3:0" + }, + "nativeSrc": "21048:17:0", + "nodeType": "YulFunctionCall", + "src": "21048:17:0" + }, + "variables": [ + { + "name": "rhs_y_off", + "nativeSrc": "21035:9:0", + "nodeType": "YulTypedName", + "src": "21035:9:0", + "type": "" + } + ] + }, + { + "nativeSrc": "21086:31:0", + "nodeType": "YulVariableDeclaration", + "src": "21086:31:0", + "value": { + "arguments": [ + { + "name": "cptr", + "nativeSrc": "21112:4:0", + "nodeType": "YulIdentifier", + "src": "21112:4:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "21099:12:0", + "nodeType": "YulIdentifier", + "src": "21099:12:0" + }, + "nativeSrc": "21099:18:0", + "nodeType": "YulFunctionCall", + "src": "21099:18:0" + }, + "variables": [ + { + "name": "lhs_x", + "nativeSrc": "21090:5:0", + "nodeType": "YulTypedName", + "src": "21090:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "21138:47:0", + "nodeType": "YulVariableDeclaration", + "src": "21138:47:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "cptr", + "nativeSrc": "21168:4:0", + "nodeType": "YulIdentifier", + "src": "21168:4:0" + }, + { + "name": "lhs_y_off", + "nativeSrc": "21174:9:0", + "nodeType": "YulIdentifier", + "src": "21174:9:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "21164:3:0", + "nodeType": "YulIdentifier", + "src": "21164:3:0" + }, + "nativeSrc": "21164:20:0", + "nodeType": "YulFunctionCall", + "src": "21164:20:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "21151:12:0", + "nodeType": "YulIdentifier", + "src": "21151:12:0" + }, + "nativeSrc": "21151:34:0", + "nodeType": "YulFunctionCall", + "src": "21151:34:0" + }, + "variables": [ + { + "name": "lhs_y", + "nativeSrc": "21142:5:0", + "nodeType": "YulTypedName", + "src": "21142:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "21206:47:0", + "nodeType": "YulVariableDeclaration", + "src": "21206:47:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "cptr", + "nativeSrc": "21236:4:0", + "nodeType": "YulIdentifier", + "src": "21236:4:0" + }, + { + "name": "rhs_x_off", + "nativeSrc": "21242:9:0", + "nodeType": "YulIdentifier", + "src": "21242:9:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "21232:3:0", + "nodeType": "YulIdentifier", + "src": "21232:3:0" + }, + "nativeSrc": "21232:20:0", + "nodeType": "YulFunctionCall", + "src": "21232:20:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "21219:12:0", + "nodeType": "YulIdentifier", + "src": "21219:12:0" + }, + "nativeSrc": "21219:34:0", + "nodeType": "YulFunctionCall", + "src": "21219:34:0" + }, + "variables": [ + { + "name": "rhs_x", + "nativeSrc": "21210:5:0", + "nodeType": "YulTypedName", + "src": "21210:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "21274:47:0", + "nodeType": "YulVariableDeclaration", + "src": "21274:47:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "cptr", + "nativeSrc": "21304:4:0", + "nodeType": "YulIdentifier", + "src": "21304:4:0" + }, + { + "name": "rhs_y_off", + "nativeSrc": "21310:9:0", + "nodeType": "YulIdentifier", + "src": "21310:9:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "21300:3:0", + "nodeType": "YulIdentifier", + "src": "21300:3:0" + }, + "nativeSrc": "21300:20:0", + "nodeType": "YulFunctionCall", + "src": "21300:20:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "21287:12:0", + "nodeType": "YulIdentifier", + "src": "21287:12:0" + }, + "nativeSrc": "21287:34:0", + "nodeType": "YulFunctionCall", + "src": "21287:34:0" + }, + "variables": [ + { + "name": "rhs_y", + "nativeSrc": "21278:5:0", + "nodeType": "YulTypedName", + "src": "21278:5:0", + "type": "" + } + ] + }, + { + "body": { + "nativeSrc": "21619:482:0", + "nodeType": "YulBlock", + "src": "21619:482:0", + "statements": [ + { + "nativeSrc": "21645:23:0", + "nodeType": "YulAssignment", + "src": "21645:23:0", + "value": { + "arguments": [ + { + "name": "cptr", + "nativeSrc": "21657:4:0", + "nodeType": "YulIdentifier", + "src": "21657:4:0" + }, + { + "kind": "number", + "nativeSrc": "21663:4:0", + "nodeType": "YulLiteral", + "src": "21663:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "21653:3:0", + "nodeType": "YulIdentifier", + "src": "21653:3:0" + }, + "nativeSrc": "21653:15:0", + "nodeType": "YulFunctionCall", + "src": "21653:15:0" + }, + "variableNames": [ + { + "name": "cptr", + "nativeSrc": "21645:4:0", + "nodeType": "YulIdentifier", + "src": "21645:4:0" + } + ] + }, + { + "nativeSrc": "21693:51:0", + "nodeType": "YulAssignment", + "src": "21693:51:0", + "value": { + "arguments": [ + { + "name": "lhs_x", + "nativeSrc": "21706:5:0", + "nodeType": "YulIdentifier", + "src": "21706:5:0" + }, + { + "arguments": [ + { + "name": "shift", + "nativeSrc": "21717:5:0", + "nodeType": "YulIdentifier", + "src": "21717:5:0" + }, + { + "arguments": [ + { + "name": "cptr", + "nativeSrc": "21737:4:0", + "nodeType": "YulIdentifier", + "src": "21737:4:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "21724:12:0", + "nodeType": "YulIdentifier", + "src": "21724:12:0" + }, + "nativeSrc": "21724:18:0", + "nodeType": "YulFunctionCall", + "src": "21724:18:0" + } + ], + "functionName": { + "name": "shl", + "nativeSrc": "21713:3:0", + "nodeType": "YulIdentifier", + "src": "21713:3:0" + }, + "nativeSrc": "21713:30:0", + "nodeType": "YulFunctionCall", + "src": "21713:30:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "21702:3:0", + "nodeType": "YulIdentifier", + "src": "21702:3:0" + }, + "nativeSrc": "21702:42:0", + "nodeType": "YulFunctionCall", + "src": "21702:42:0" + }, + "variableNames": [ + { + "name": "lhs_x", + "nativeSrc": "21693:5:0", + "nodeType": "YulIdentifier", + "src": "21693:5:0" + } + ] + }, + { + "nativeSrc": "21769:67:0", + "nodeType": "YulAssignment", + "src": "21769:67:0", + "value": { + "arguments": [ + { + "name": "lhs_y", + "nativeSrc": "21782:5:0", + "nodeType": "YulIdentifier", + "src": "21782:5:0" + }, + { + "arguments": [ + { + "name": "shift", + "nativeSrc": "21793:5:0", + "nodeType": "YulIdentifier", + "src": "21793:5:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "cptr", + "nativeSrc": "21817:4:0", + "nodeType": "YulIdentifier", + "src": "21817:4:0" + }, + { + "name": "lhs_y_off", + "nativeSrc": "21823:9:0", + "nodeType": "YulIdentifier", + "src": "21823:9:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "21813:3:0", + "nodeType": "YulIdentifier", + "src": "21813:3:0" + }, + "nativeSrc": "21813:20:0", + "nodeType": "YulFunctionCall", + "src": "21813:20:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "21800:12:0", + "nodeType": "YulIdentifier", + "src": "21800:12:0" + }, + "nativeSrc": "21800:34:0", + "nodeType": "YulFunctionCall", + "src": "21800:34:0" + } + ], + "functionName": { + "name": "shl", + "nativeSrc": "21789:3:0", + "nodeType": "YulIdentifier", + "src": "21789:3:0" + }, + "nativeSrc": "21789:46:0", + "nodeType": "YulFunctionCall", + "src": "21789:46:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "21778:3:0", + "nodeType": "YulIdentifier", + "src": "21778:3:0" + }, + "nativeSrc": "21778:58:0", + "nodeType": "YulFunctionCall", + "src": "21778:58:0" + }, + "variableNames": [ + { + "name": "lhs_y", + "nativeSrc": "21769:5:0", + "nodeType": "YulIdentifier", + "src": "21769:5:0" + } + ] + }, + { + "nativeSrc": "21861:67:0", + "nodeType": "YulAssignment", + "src": "21861:67:0", + "value": { + "arguments": [ + { + "name": "rhs_x", + "nativeSrc": "21874:5:0", + "nodeType": "YulIdentifier", + "src": "21874:5:0" + }, + { + "arguments": [ + { + "name": "shift", + "nativeSrc": "21885:5:0", + "nodeType": "YulIdentifier", + "src": "21885:5:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "cptr", + "nativeSrc": "21909:4:0", + "nodeType": "YulIdentifier", + "src": "21909:4:0" + }, + { + "name": "rhs_x_off", + "nativeSrc": "21915:9:0", + "nodeType": "YulIdentifier", + "src": "21915:9:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "21905:3:0", + "nodeType": "YulIdentifier", + "src": "21905:3:0" + }, + "nativeSrc": "21905:20:0", + "nodeType": "YulFunctionCall", + "src": "21905:20:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "21892:12:0", + "nodeType": "YulIdentifier", + "src": "21892:12:0" + }, + "nativeSrc": "21892:34:0", + "nodeType": "YulFunctionCall", + "src": "21892:34:0" + } + ], + "functionName": { + "name": "shl", + "nativeSrc": "21881:3:0", + "nodeType": "YulIdentifier", + "src": "21881:3:0" + }, + "nativeSrc": "21881:46:0", + "nodeType": "YulFunctionCall", + "src": "21881:46:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "21870:3:0", + "nodeType": "YulIdentifier", + "src": "21870:3:0" + }, + "nativeSrc": "21870:58:0", + "nodeType": "YulFunctionCall", + "src": "21870:58:0" + }, + "variableNames": [ + { + "name": "rhs_x", + "nativeSrc": "21861:5:0", + "nodeType": "YulIdentifier", + "src": "21861:5:0" + } + ] + }, + { + "nativeSrc": "21953:67:0", + "nodeType": "YulAssignment", + "src": "21953:67:0", + "value": { + "arguments": [ + { + "name": "rhs_y", + "nativeSrc": "21966:5:0", + "nodeType": "YulIdentifier", + "src": "21966:5:0" + }, + { + "arguments": [ + { + "name": "shift", + "nativeSrc": "21977:5:0", + "nodeType": "YulIdentifier", + "src": "21977:5:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "cptr", + "nativeSrc": "22001:4:0", + "nodeType": "YulIdentifier", + "src": "22001:4:0" + }, + { + "name": "rhs_y_off", + "nativeSrc": "22007:9:0", + "nodeType": "YulIdentifier", + "src": "22007:9:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "21997:3:0", + "nodeType": "YulIdentifier", + "src": "21997:3:0" + }, + "nativeSrc": "21997:20:0", + "nodeType": "YulFunctionCall", + "src": "21997:20:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "21984:12:0", + "nodeType": "YulIdentifier", + "src": "21984:12:0" + }, + "nativeSrc": "21984:34:0", + "nodeType": "YulFunctionCall", + "src": "21984:34:0" + } + ], + "functionName": { + "name": "shl", + "nativeSrc": "21973:3:0", + "nodeType": "YulIdentifier", + "src": "21973:3:0" + }, + "nativeSrc": "21973:46:0", + "nodeType": "YulFunctionCall", + "src": "21973:46:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "21962:3:0", + "nodeType": "YulIdentifier", + "src": "21962:3:0" + }, + "nativeSrc": "21962:58:0", + "nodeType": "YulFunctionCall", + "src": "21962:58:0" + }, + "variableNames": [ + { + "name": "rhs_y", + "nativeSrc": "21953:5:0", + "nodeType": "YulIdentifier", + "src": "21953:5:0" + } + ] + }, + { + "nativeSrc": "22045:34:0", + "nodeType": "YulAssignment", + "src": "22045:34:0", + "value": { + "arguments": [ + { + "name": "shift", + "nativeSrc": "22058:5:0", + "nodeType": "YulIdentifier", + "src": "22058:5:0" + }, + { + "name": "num_limb_bits", + "nativeSrc": "22065:13:0", + "nodeType": "YulIdentifier", + "src": "22065:13:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "22054:3:0", + "nodeType": "YulIdentifier", + "src": "22054:3:0" + }, + "nativeSrc": "22054:25:0", + "nodeType": "YulFunctionCall", + "src": "22054:25:0" + }, + "variableNames": [ + { + "name": "shift", + "nativeSrc": "22045:5:0", + "nodeType": "YulIdentifier", + "src": "22045:5:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "cptr", + "nativeSrc": "21556:4:0", + "nodeType": "YulIdentifier", + "src": "21556:4:0" + }, + { + "name": "cptr_end", + "nativeSrc": "21562:8:0", + "nodeType": "YulIdentifier", + "src": "21562:8:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "21553:2:0", + "nodeType": "YulIdentifier", + "src": "21553:2:0" + }, + "nativeSrc": "21553:18:0", + "nodeType": "YulFunctionCall", + "src": "21553:18:0" + }, + "nativeSrc": "21342:759:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "21596:2:0", + "nodeType": "YulBlock", + "src": "21596:2:0", + "statements": [] + }, + "pre": { + "nativeSrc": "21370:158:0", + "nodeType": "YulBlock", + "src": "21370:158:0", + "statements": [ + { + "nativeSrc": "21400:47:0", + "nodeType": "YulVariableDeclaration", + "src": "21400:47:0", + "value": { + "arguments": [ + { + "name": "cptr", + "nativeSrc": "21420:4:0", + "nodeType": "YulIdentifier", + "src": "21420:4:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "21430:4:0", + "nodeType": "YulLiteral", + "src": "21430:4:0", + "type": "", + "value": "0x20" + }, + { + "name": "num_limbs", + "nativeSrc": "21436:9:0", + "nodeType": "YulIdentifier", + "src": "21436:9:0" + } + ], + "functionName": { + "name": "mul", + "nativeSrc": "21426:3:0", + "nodeType": "YulIdentifier", + "src": "21426:3:0" + }, + "nativeSrc": "21426:20:0", + "nodeType": "YulFunctionCall", + "src": "21426:20:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "21416:3:0", + "nodeType": "YulIdentifier", + "src": "21416:3:0" + }, + "nativeSrc": "21416:31:0", + "nodeType": "YulFunctionCall", + "src": "21416:31:0" + }, + "variables": [ + { + "name": "cptr_end", + "nativeSrc": "21404:8:0", + "nodeType": "YulTypedName", + "src": "21404:8:0", + "type": "" + } + ] + }, + { + "nativeSrc": "21476:26:0", + "nodeType": "YulVariableDeclaration", + "src": "21476:26:0", + "value": { + "name": "num_limb_bits", + "nativeSrc": "21489:13:0", + "nodeType": "YulIdentifier", + "src": "21489:13:0" + }, + "variables": [ + { + "name": "shift", + "nativeSrc": "21480:5:0", + "nodeType": "YulTypedName", + "src": "21480:5:0", + "type": "" + } + ] + } + ] + }, + "src": "21342:759:0" + }, + { + "nativeSrc": "22123:109:0", + "nodeType": "YulAssignment", + "src": "22123:109:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "22138:7:0", + "nodeType": "YulIdentifier", + "src": "22138:7:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "lhs_y", + "nativeSrc": "22157:5:0", + "nodeType": "YulIdentifier", + "src": "22157:5:0" + }, + { + "name": "lhs_y", + "nativeSrc": "22164:5:0", + "nodeType": "YulIdentifier", + "src": "22164:5:0" + }, + { + "name": "q", + "nativeSrc": "22171:1:0", + "nodeType": "YulIdentifier", + "src": "22171:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "22150:6:0", + "nodeType": "YulIdentifier", + "src": "22150:6:0" + }, + "nativeSrc": "22150:23:0", + "nodeType": "YulFunctionCall", + "src": "22150:23:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "lhs_x", + "nativeSrc": "22189:5:0", + "nodeType": "YulIdentifier", + "src": "22189:5:0" + }, + { + "arguments": [ + { + "name": "lhs_x", + "nativeSrc": "22203:5:0", + "nodeType": "YulIdentifier", + "src": "22203:5:0" + }, + { + "name": "lhs_x", + "nativeSrc": "22210:5:0", + "nodeType": "YulIdentifier", + "src": "22210:5:0" + }, + { + "name": "q", + "nativeSrc": "22217:1:0", + "nodeType": "YulIdentifier", + "src": "22217:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "22196:6:0", + "nodeType": "YulIdentifier", + "src": "22196:6:0" + }, + "nativeSrc": "22196:23:0", + "nodeType": "YulFunctionCall", + "src": "22196:23:0" + }, + { + "name": "q", + "nativeSrc": "22221:1:0", + "nodeType": "YulIdentifier", + "src": "22221:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "22182:6:0", + "nodeType": "YulIdentifier", + "src": "22182:6:0" + }, + "nativeSrc": "22182:41:0", + "nodeType": "YulFunctionCall", + "src": "22182:41:0" + }, + { + "kind": "number", + "nativeSrc": "22225:1:0", + "nodeType": "YulLiteral", + "src": "22225:1:0", + "type": "", + "value": "3" + }, + { + "name": "q", + "nativeSrc": "22228:1:0", + "nodeType": "YulIdentifier", + "src": "22228:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "22175:6:0", + "nodeType": "YulIdentifier", + "src": "22175:6:0" + }, + "nativeSrc": "22175:55:0", + "nodeType": "YulFunctionCall", + "src": "22175:55:0" + } + ], + "functionName": { + "name": "eq", + "nativeSrc": "22147:2:0", + "nodeType": "YulIdentifier", + "src": "22147:2:0" + }, + "nativeSrc": "22147:84:0", + "nodeType": "YulFunctionCall", + "src": "22147:84:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "22134:3:0", + "nodeType": "YulIdentifier", + "src": "22134:3:0" + }, + "nativeSrc": "22134:98:0", + "nodeType": "YulFunctionCall", + "src": "22134:98:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "22123:7:0", + "nodeType": "YulIdentifier", + "src": "22123:7:0" + } + ] + }, + { + "nativeSrc": "22253:109:0", + "nodeType": "YulAssignment", + "src": "22253:109:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "22268:7:0", + "nodeType": "YulIdentifier", + "src": "22268:7:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "rhs_y", + "nativeSrc": "22287:5:0", + "nodeType": "YulIdentifier", + "src": "22287:5:0" + }, + { + "name": "rhs_y", + "nativeSrc": "22294:5:0", + "nodeType": "YulIdentifier", + "src": "22294:5:0" + }, + { + "name": "q", + "nativeSrc": "22301:1:0", + "nodeType": "YulIdentifier", + "src": "22301:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "22280:6:0", + "nodeType": "YulIdentifier", + "src": "22280:6:0" + }, + "nativeSrc": "22280:23:0", + "nodeType": "YulFunctionCall", + "src": "22280:23:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "rhs_x", + "nativeSrc": "22319:5:0", + "nodeType": "YulIdentifier", + "src": "22319:5:0" + }, + { + "arguments": [ + { + "name": "rhs_x", + "nativeSrc": "22333:5:0", + "nodeType": "YulIdentifier", + "src": "22333:5:0" + }, + { + "name": "rhs_x", + "nativeSrc": "22340:5:0", + "nodeType": "YulIdentifier", + "src": "22340:5:0" + }, + { + "name": "q", + "nativeSrc": "22347:1:0", + "nodeType": "YulIdentifier", + "src": "22347:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "22326:6:0", + "nodeType": "YulIdentifier", + "src": "22326:6:0" + }, + "nativeSrc": "22326:23:0", + "nodeType": "YulFunctionCall", + "src": "22326:23:0" + }, + { + "name": "q", + "nativeSrc": "22351:1:0", + "nodeType": "YulIdentifier", + "src": "22351:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "22312:6:0", + "nodeType": "YulIdentifier", + "src": "22312:6:0" + }, + "nativeSrc": "22312:41:0", + "nodeType": "YulFunctionCall", + "src": "22312:41:0" + }, + { + "kind": "number", + "nativeSrc": "22355:1:0", + "nodeType": "YulLiteral", + "src": "22355:1:0", + "type": "", + "value": "3" + }, + { + "name": "q", + "nativeSrc": "22358:1:0", + "nodeType": "YulIdentifier", + "src": "22358:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "22305:6:0", + "nodeType": "YulIdentifier", + "src": "22305:6:0" + }, + "nativeSrc": "22305:55:0", + "nodeType": "YulFunctionCall", + "src": "22305:55:0" + } + ], + "functionName": { + "name": "eq", + "nativeSrc": "22277:2:0", + "nodeType": "YulIdentifier", + "src": "22277:2:0" + }, + "nativeSrc": "22277:84:0", + "nodeType": "YulFunctionCall", + "src": "22277:84:0" + } + ], + "functionName": { + "name": "and", + "nativeSrc": "22264:3:0", + "nodeType": "YulIdentifier", + "src": "22264:3:0" + }, + "nativeSrc": "22264:98:0", + "nodeType": "YulFunctionCall", + "src": "22264:98:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "22253:7:0", + "nodeType": "YulIdentifier", + "src": "22253:7:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "ACC_LHS_X_MPTR", + "nativeSrc": "22391:14:0", + "nodeType": "YulIdentifier", + "src": "22391:14:0" + }, + { + "name": "lhs_x", + "nativeSrc": "22407:5:0", + "nodeType": "YulIdentifier", + "src": "22407:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "22384:6:0", + "nodeType": "YulIdentifier", + "src": "22384:6:0" + }, + "nativeSrc": "22384:29:0", + "nodeType": "YulFunctionCall", + "src": "22384:29:0" + }, + "nativeSrc": "22384:29:0", + "nodeType": "YulExpressionStatement", + "src": "22384:29:0" + }, + { + "expression": { + "arguments": [ + { + "name": "ACC_LHS_Y_MPTR", + "nativeSrc": "22441:14:0", + "nodeType": "YulIdentifier", + "src": "22441:14:0" + }, + { + "name": "lhs_y", + "nativeSrc": "22457:5:0", + "nodeType": "YulIdentifier", + "src": "22457:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "22434:6:0", + "nodeType": "YulIdentifier", + "src": "22434:6:0" + }, + "nativeSrc": "22434:29:0", + "nodeType": "YulFunctionCall", + "src": "22434:29:0" + }, + "nativeSrc": "22434:29:0", + "nodeType": "YulExpressionStatement", + "src": "22434:29:0" + }, + { + "expression": { + "arguments": [ + { + "name": "ACC_RHS_X_MPTR", + "nativeSrc": "22491:14:0", + "nodeType": "YulIdentifier", + "src": "22491:14:0" + }, + { + "name": "rhs_x", + "nativeSrc": "22507:5:0", + "nodeType": "YulIdentifier", + "src": "22507:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "22484:6:0", + "nodeType": "YulIdentifier", + "src": "22484:6:0" + }, + "nativeSrc": "22484:29:0", + "nodeType": "YulFunctionCall", + "src": "22484:29:0" + }, + "nativeSrc": "22484:29:0", + "nodeType": "YulExpressionStatement", + "src": "22484:29:0" + }, + { + "expression": { + "arguments": [ + { + "name": "ACC_RHS_Y_MPTR", + "nativeSrc": "22541:14:0", + "nodeType": "YulIdentifier", + "src": "22541:14:0" + }, + { + "name": "rhs_y", + "nativeSrc": "22557:5:0", + "nodeType": "YulIdentifier", + "src": "22557:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "22534:6:0", + "nodeType": "YulIdentifier", + "src": "22534:6:0" + }, + "nativeSrc": "22534:29:0", + "nodeType": "YulFunctionCall", + "src": "22534:29:0" + }, + "nativeSrc": "22534:29:0", + "nodeType": "YulExpressionStatement", + "src": "22534:29:0" + } + ] + }, + "condition": { + "arguments": [ + { + "name": "HAS_ACCUMULATOR_MPTR", + "nativeSrc": "20653:20:0", + "nodeType": "YulIdentifier", + "src": "20653:20:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "20647:5:0", + "nodeType": "YulIdentifier", + "src": "20647:5:0" + }, + "nativeSrc": "20647:27:0", + "nodeType": "YulFunctionCall", + "src": "20647:27:0" + }, + "nativeSrc": "20644:1937:0", + "nodeType": "YulIf", + "src": "20644:1937:0" + }, + { + "expression": { + "arguments": [ + { + "name": "q", + "nativeSrc": "22603:1:0", + "nodeType": "YulIdentifier", + "src": "22603:1:0" + } + ], + "functionName": { + "name": "pop", + "nativeSrc": "22599:3:0", + "nodeType": "YulIdentifier", + "src": "22599:3:0" + }, + "nativeSrc": "22599:6:0", + "nodeType": "YulFunctionCall", + "src": "22599:6:0" + }, + "nativeSrc": "22599:6:0", + "nodeType": "YulExpressionStatement", + "src": "22599:6:0" + } + ] + }, + { + "body": { + "nativeSrc": "22719:44:0", + "nodeType": "YulBlock", + "src": "22719:44:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "22744:1:0", + "nodeType": "YulLiteral", + "src": "22744:1:0", + "type": "", + "value": "0" + }, + { + "kind": "number", + "nativeSrc": "22747:1:0", + "nodeType": "YulLiteral", + "src": "22747:1:0", + "type": "", + "value": "0" + } + ], + "functionName": { + "name": "revert", + "nativeSrc": "22737:6:0", + "nodeType": "YulIdentifier", + "src": "22737:6:0" + }, + "nativeSrc": "22737:12:0", + "nodeType": "YulFunctionCall", + "src": "22737:12:0" + }, + "nativeSrc": "22737:12:0", + "nodeType": "YulExpressionStatement", + "src": "22737:12:0" + } + ] + }, + "condition": { + "arguments": [ + { + "name": "success", + "nativeSrc": "22710:7:0", + "nodeType": "YulIdentifier", + "src": "22710:7:0" + } + ], + "functionName": { + "name": "iszero", + "nativeSrc": "22703:6:0", + "nodeType": "YulIdentifier", + "src": "22703:6:0" + }, + "nativeSrc": "22703:15:0", + "nodeType": "YulFunctionCall", + "src": "22703:15:0" + }, + "nativeSrc": "22700:63:0", + "nodeType": "YulIf", + "src": "22700:63:0" + }, + { + "nativeSrc": "22845:3087:0", + "nodeType": "YulBlock", + "src": "22845:3087:0", + "statements": [ + { + "nativeSrc": "22863:22:0", + "nodeType": "YulVariableDeclaration", + "src": "22863:22:0", + "value": { + "arguments": [ + { + "name": "K_MPTR", + "nativeSrc": "22878:6:0", + "nodeType": "YulIdentifier", + "src": "22878:6:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "22872:5:0", + "nodeType": "YulIdentifier", + "src": "22872:5:0" + }, + "nativeSrc": "22872:13:0", + "nodeType": "YulFunctionCall", + "src": "22872:13:0" + }, + "variables": [ + { + "name": "k", + "nativeSrc": "22867:1:0", + "nodeType": "YulTypedName", + "src": "22867:1:0", + "type": "" + } + ] + }, + { + "nativeSrc": "22902:22:0", + "nodeType": "YulVariableDeclaration", + "src": "22902:22:0", + "value": { + "arguments": [ + { + "name": "X_MPTR", + "nativeSrc": "22917:6:0", + "nodeType": "YulIdentifier", + "src": "22917:6:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "22911:5:0", + "nodeType": "YulIdentifier", + "src": "22911:5:0" + }, + "nativeSrc": "22911:13:0", + "nodeType": "YulFunctionCall", + "src": "22911:13:0" + }, + "variables": [ + { + "name": "x", + "nativeSrc": "22906:1:0", + "nodeType": "YulTypedName", + "src": "22906:1:0", + "type": "" + } + ] + }, + { + "nativeSrc": "22941:12:0", + "nodeType": "YulVariableDeclaration", + "src": "22941:12:0", + "value": { + "name": "x", + "nativeSrc": "22952:1:0", + "nodeType": "YulIdentifier", + "src": "22952:1:0" + }, + "variables": [ + { + "name": "x_n", + "nativeSrc": "22945:3:0", + "nodeType": "YulTypedName", + "src": "22945:3:0", + "type": "" + } + ] + }, + { + "body": { + "nativeSrc": "23101:66:0", + "nodeType": "YulBlock", + "src": "23101:66:0", + "statements": [ + { + "nativeSrc": "23123:26:0", + "nodeType": "YulAssignment", + "src": "23123:26:0", + "value": { + "arguments": [ + { + "name": "x_n", + "nativeSrc": "23137:3:0", + "nodeType": "YulIdentifier", + "src": "23137:3:0" + }, + { + "name": "x_n", + "nativeSrc": "23142:3:0", + "nodeType": "YulIdentifier", + "src": "23142:3:0" + }, + { + "name": "r", + "nativeSrc": "23147:1:0", + "nodeType": "YulIdentifier", + "src": "23147:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "23130:6:0", + "nodeType": "YulIdentifier", + "src": "23130:6:0" + }, + "nativeSrc": "23130:19:0", + "nodeType": "YulFunctionCall", + "src": "23130:19:0" + }, + "variableNames": [ + { + "name": "x_n", + "nativeSrc": "23123:3:0", + "nodeType": "YulIdentifier", + "src": "23123:3:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "idx", + "nativeSrc": "23034:3:0", + "nodeType": "YulIdentifier", + "src": "23034:3:0" + }, + { + "name": "k", + "nativeSrc": "23039:1:0", + "nodeType": "YulIdentifier", + "src": "23039:1:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "23031:2:0", + "nodeType": "YulIdentifier", + "src": "23031:2:0" + }, + "nativeSrc": "23031:10:0", + "nodeType": "YulFunctionCall", + "src": "23031:10:0" + }, + "nativeSrc": "22970:197:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "23062:22:0", + "nodeType": "YulBlock", + "src": "23062:22:0", + "statements": [ + { + "nativeSrc": "23064:18:0", + "nodeType": "YulAssignment", + "src": "23064:18:0", + "value": { + "arguments": [ + { + "name": "idx", + "nativeSrc": "23075:3:0", + "nodeType": "YulIdentifier", + "src": "23075:3:0" + }, + { + "kind": "number", + "nativeSrc": "23080:1:0", + "nodeType": "YulLiteral", + "src": "23080:1:0", + "type": "", + "value": "1" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "23071:3:0", + "nodeType": "YulIdentifier", + "src": "23071:3:0" + }, + "nativeSrc": "23071:11:0", + "nodeType": "YulFunctionCall", + "src": "23071:11:0" + }, + "variableNames": [ + { + "name": "idx", + "nativeSrc": "23064:3:0", + "nodeType": "YulIdentifier", + "src": "23064:3:0" + } + ] + } + ] + }, + "pre": { + "nativeSrc": "22994:16:0", + "nodeType": "YulBlock", + "src": "22994:16:0", + "statements": [ + { + "nativeSrc": "22996:12:0", + "nodeType": "YulVariableDeclaration", + "src": "22996:12:0", + "value": { + "kind": "number", + "nativeSrc": "23007:1:0", + "nodeType": "YulLiteral", + "src": "23007:1:0", + "type": "", + "value": "0" + }, + "variables": [ + { + "name": "idx", + "nativeSrc": "23000:3:0", + "nodeType": "YulTypedName", + "src": "23000:3:0", + "type": "" + } + ] + } + ] + }, + "src": "22970:197:0" + }, + { + "nativeSrc": "23185:30:0", + "nodeType": "YulVariableDeclaration", + "src": "23185:30:0", + "value": { + "arguments": [ + { + "name": "OMEGA_MPTR", + "nativeSrc": "23204:10:0", + "nodeType": "YulIdentifier", + "src": "23204:10:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "23198:5:0", + "nodeType": "YulIdentifier", + "src": "23198:5:0" + }, + "nativeSrc": "23198:17:0", + "nodeType": "YulFunctionCall", + "src": "23198:17:0" + }, + "variables": [ + { + "name": "omega", + "nativeSrc": "23189:5:0", + "nodeType": "YulTypedName", + "src": "23189:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "23233:20:0", + "nodeType": "YulVariableDeclaration", + "src": "23233:20:0", + "value": { + "name": "X_N_MPTR", + "nativeSrc": "23245:8:0", + "nodeType": "YulIdentifier", + "src": "23245:8:0" + }, + "variables": [ + { + "name": "mptr", + "nativeSrc": "23237:4:0", + "nodeType": "YulTypedName", + "src": "23237:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "23270:71:0", + "nodeType": "YulVariableDeclaration", + "src": "23270:71:0", + "value": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "23290:4:0", + "nodeType": "YulIdentifier", + "src": "23290:4:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "23300:4:0", + "nodeType": "YulLiteral", + "src": "23300:4:0", + "type": "", + "value": "0x20" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "NUM_INSTANCES_MPTR", + "nativeSrc": "23316:18:0", + "nodeType": "YulIdentifier", + "src": "23316:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "23310:5:0", + "nodeType": "YulIdentifier", + "src": "23310:5:0" + }, + "nativeSrc": "23310:25:0", + "nodeType": "YulFunctionCall", + "src": "23310:25:0" + }, + { + "kind": "number", + "nativeSrc": "23337:1:0", + "nodeType": "YulLiteral", + "src": "23337:1:0", + "type": "", + "value": "6" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "23306:3:0", + "nodeType": "YulIdentifier", + "src": "23306:3:0" + }, + "nativeSrc": "23306:33:0", + "nodeType": "YulFunctionCall", + "src": "23306:33:0" + } + ], + "functionName": { + "name": "mul", + "nativeSrc": "23296:3:0", + "nodeType": "YulIdentifier", + "src": "23296:3:0" + }, + "nativeSrc": "23296:44:0", + "nodeType": "YulFunctionCall", + "src": "23296:44:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "23286:3:0", + "nodeType": "YulIdentifier", + "src": "23286:3:0" + }, + "nativeSrc": "23286:55:0", + "nodeType": "YulFunctionCall", + "src": "23286:55:0" + }, + "variables": [ + { + "name": "mptr_end", + "nativeSrc": "23274:8:0", + "nodeType": "YulTypedName", + "src": "23274:8:0", + "type": "" + } + ] + }, + { + "body": { + "nativeSrc": "23536:155:0", + "nodeType": "YulBlock", + "src": "23536:155:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "23565:4:0", + "nodeType": "YulIdentifier", + "src": "23565:4:0" + }, + { + "arguments": [ + { + "name": "x", + "nativeSrc": "23578:1:0", + "nodeType": "YulIdentifier", + "src": "23578:1:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "23585:1:0", + "nodeType": "YulIdentifier", + "src": "23585:1:0" + }, + { + "name": "pow_of_omega", + "nativeSrc": "23588:12:0", + "nodeType": "YulIdentifier", + "src": "23588:12:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "23581:3:0", + "nodeType": "YulIdentifier", + "src": "23581:3:0" + }, + "nativeSrc": "23581:20:0", + "nodeType": "YulFunctionCall", + "src": "23581:20:0" + }, + { + "name": "r", + "nativeSrc": "23603:1:0", + "nodeType": "YulIdentifier", + "src": "23603:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "23571:6:0", + "nodeType": "YulIdentifier", + "src": "23571:6:0" + }, + "nativeSrc": "23571:34:0", + "nodeType": "YulFunctionCall", + "src": "23571:34:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "23558:6:0", + "nodeType": "YulIdentifier", + "src": "23558:6:0" + }, + "nativeSrc": "23558:48:0", + "nodeType": "YulFunctionCall", + "src": "23558:48:0" + }, + "nativeSrc": "23558:48:0", + "nodeType": "YulExpressionStatement", + "src": "23558:48:0" + }, + { + "nativeSrc": "23627:46:0", + "nodeType": "YulAssignment", + "src": "23627:46:0", + "value": { + "arguments": [ + { + "name": "pow_of_omega", + "nativeSrc": "23650:12:0", + "nodeType": "YulIdentifier", + "src": "23650:12:0" + }, + { + "name": "omega", + "nativeSrc": "23664:5:0", + "nodeType": "YulIdentifier", + "src": "23664:5:0" + }, + { + "name": "r", + "nativeSrc": "23671:1:0", + "nodeType": "YulIdentifier", + "src": "23671:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "23643:6:0", + "nodeType": "YulIdentifier", + "src": "23643:6:0" + }, + "nativeSrc": "23643:30:0", + "nodeType": "YulFunctionCall", + "src": "23643:30:0" + }, + "variableNames": [ + { + "name": "pow_of_omega", + "nativeSrc": "23627:12:0", + "nodeType": "YulIdentifier", + "src": "23627:12:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "23456:4:0", + "nodeType": "YulIdentifier", + "src": "23456:4:0" + }, + { + "name": "mptr_end", + "nativeSrc": "23462:8:0", + "nodeType": "YulIdentifier", + "src": "23462:8:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "23453:2:0", + "nodeType": "YulIdentifier", + "src": "23453:2:0" + }, + "nativeSrc": "23453:18:0", + "nodeType": "YulFunctionCall", + "src": "23453:18:0" + }, + "nativeSrc": "23358:333:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "23492:27:0", + "nodeType": "YulBlock", + "src": "23492:27:0", + "statements": [ + { + "nativeSrc": "23494:23:0", + "nodeType": "YulAssignment", + "src": "23494:23:0", + "value": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "23506:4:0", + "nodeType": "YulIdentifier", + "src": "23506:4:0" + }, + { + "kind": "number", + "nativeSrc": "23512:4:0", + "nodeType": "YulLiteral", + "src": "23512:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "23502:3:0", + "nodeType": "YulIdentifier", + "src": "23502:3:0" + }, + "nativeSrc": "23502:15:0", + "nodeType": "YulFunctionCall", + "src": "23502:15:0" + }, + "variableNames": [ + { + "name": "mptr", + "nativeSrc": "23494:4:0", + "nodeType": "YulIdentifier", + "src": "23494:4:0" + } + ] + } + ] + }, + "pre": { + "nativeSrc": "23382:50:0", + "nodeType": "YulBlock", + "src": "23382:50:0", + "statements": [ + { + "nativeSrc": "23384:46:0", + "nodeType": "YulVariableDeclaration", + "src": "23384:46:0", + "value": { + "arguments": [ + { + "name": "OMEGA_INV_TO_L_MPTR", + "nativeSrc": "23410:19:0", + "nodeType": "YulIdentifier", + "src": "23410:19:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "23404:5:0", + "nodeType": "YulIdentifier", + "src": "23404:5:0" + }, + "nativeSrc": "23404:26:0", + "nodeType": "YulFunctionCall", + "src": "23404:26:0" + }, + "variables": [ + { + "name": "pow_of_omega", + "nativeSrc": "23388:12:0", + "nodeType": "YulTypedName", + "src": "23388:12:0", + "type": "" + } + ] + } + ] + }, + "src": "23358:333:0" + }, + { + "nativeSrc": "23708:44:0", + "nodeType": "YulVariableDeclaration", + "src": "23708:44:0", + "value": { + "arguments": [ + { + "name": "x_n", + "nativeSrc": "23734:3:0", + "nodeType": "YulIdentifier", + "src": "23734:3:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "23743:1:0", + "nodeType": "YulIdentifier", + "src": "23743:1:0" + }, + { + "kind": "number", + "nativeSrc": "23746:1:0", + "nodeType": "YulLiteral", + "src": "23746:1:0", + "type": "", + "value": "1" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "23739:3:0", + "nodeType": "YulIdentifier", + "src": "23739:3:0" + }, + "nativeSrc": "23739:9:0", + "nodeType": "YulFunctionCall", + "src": "23739:9:0" + }, + { + "name": "r", + "nativeSrc": "23750:1:0", + "nodeType": "YulIdentifier", + "src": "23750:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "23727:6:0", + "nodeType": "YulIdentifier", + "src": "23727:6:0" + }, + "nativeSrc": "23727:25:0", + "nodeType": "YulFunctionCall", + "src": "23727:25:0" + }, + "variables": [ + { + "name": "x_n_minus_1", + "nativeSrc": "23712:11:0", + "nodeType": "YulTypedName", + "src": "23712:11:0", + "type": "" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "mptr_end", + "nativeSrc": "23776:8:0", + "nodeType": "YulIdentifier", + "src": "23776:8:0" + }, + { + "name": "x_n_minus_1", + "nativeSrc": "23786:11:0", + "nodeType": "YulIdentifier", + "src": "23786:11:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "23769:6:0", + "nodeType": "YulIdentifier", + "src": "23769:6:0" + }, + "nativeSrc": "23769:29:0", + "nodeType": "YulFunctionCall", + "src": "23769:29:0" + }, + "nativeSrc": "23769:29:0", + "nodeType": "YulExpressionStatement", + "src": "23769:29:0" + }, + { + "nativeSrc": "23815:66:0", + "nodeType": "YulAssignment", + "src": "23815:66:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "23839:7:0", + "nodeType": "YulIdentifier", + "src": "23839:7:0" + }, + { + "name": "X_N_MPTR", + "nativeSrc": "23848:8:0", + "nodeType": "YulIdentifier", + "src": "23848:8:0" + }, + { + "arguments": [ + { + "name": "mptr_end", + "nativeSrc": "23862:8:0", + "nodeType": "YulIdentifier", + "src": "23862:8:0" + }, + { + "kind": "number", + "nativeSrc": "23872:4:0", + "nodeType": "YulLiteral", + "src": "23872:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "23858:3:0", + "nodeType": "YulIdentifier", + "src": "23858:3:0" + }, + "nativeSrc": "23858:19:0", + "nodeType": "YulFunctionCall", + "src": "23858:19:0" + }, + { + "name": "r", + "nativeSrc": "23879:1:0", + "nodeType": "YulIdentifier", + "src": "23879:1:0" + } + ], + "functionName": { + "name": "batch_invert", + "nativeSrc": "23826:12:0", + "nodeType": "YulIdentifier", + "src": "23826:12:0" + }, + "nativeSrc": "23826:55:0", + "nodeType": "YulFunctionCall", + "src": "23826:55:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "23815:7:0", + "nodeType": "YulIdentifier", + "src": "23815:7:0" + } + ] + }, + { + "nativeSrc": "23899:16:0", + "nodeType": "YulAssignment", + "src": "23899:16:0", + "value": { + "name": "X_N_MPTR", + "nativeSrc": "23907:8:0", + "nodeType": "YulIdentifier", + "src": "23907:8:0" + }, + "variableNames": [ + { + "name": "mptr", + "nativeSrc": "23899:4:0", + "nodeType": "YulIdentifier", + "src": "23899:4:0" + } + ] + }, + { + "nativeSrc": "23932:59:0", + "nodeType": "YulVariableDeclaration", + "src": "23932:59:0", + "value": { + "arguments": [ + { + "name": "x_n_minus_1", + "nativeSrc": "23957:11:0", + "nodeType": "YulIdentifier", + "src": "23957:11:0" + }, + { + "arguments": [ + { + "name": "N_INV_MPTR", + "nativeSrc": "23976:10:0", + "nodeType": "YulIdentifier", + "src": "23976:10:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "23970:5:0", + "nodeType": "YulIdentifier", + "src": "23970:5:0" + }, + "nativeSrc": "23970:17:0", + "nodeType": "YulFunctionCall", + "src": "23970:17:0" + }, + { + "name": "r", + "nativeSrc": "23989:1:0", + "nodeType": "YulIdentifier", + "src": "23989:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "23950:6:0", + "nodeType": "YulIdentifier", + "src": "23950:6:0" + }, + "nativeSrc": "23950:41:0", + "nodeType": "YulFunctionCall", + "src": "23950:41:0" + }, + "variables": [ + { + "name": "l_i_common", + "nativeSrc": "23936:10:0", + "nodeType": "YulTypedName", + "src": "23936:10:0", + "type": "" + } + ] + }, + { + "body": { + "nativeSrc": "24186:180:0", + "nodeType": "YulBlock", + "src": "24186:180:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "24215:4:0", + "nodeType": "YulIdentifier", + "src": "24215:4:0" + }, + { + "arguments": [ + { + "name": "l_i_common", + "nativeSrc": "24228:10:0", + "nodeType": "YulIdentifier", + "src": "24228:10:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "24253:4:0", + "nodeType": "YulIdentifier", + "src": "24253:4:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "24247:5:0", + "nodeType": "YulIdentifier", + "src": "24247:5:0" + }, + "nativeSrc": "24247:11:0", + "nodeType": "YulFunctionCall", + "src": "24247:11:0" + }, + { + "name": "pow_of_omega", + "nativeSrc": "24260:12:0", + "nodeType": "YulIdentifier", + "src": "24260:12:0" + }, + { + "name": "r", + "nativeSrc": "24274:1:0", + "nodeType": "YulIdentifier", + "src": "24274:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "24240:6:0", + "nodeType": "YulIdentifier", + "src": "24240:6:0" + }, + "nativeSrc": "24240:36:0", + "nodeType": "YulFunctionCall", + "src": "24240:36:0" + }, + { + "name": "r", + "nativeSrc": "24278:1:0", + "nodeType": "YulIdentifier", + "src": "24278:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "24221:6:0", + "nodeType": "YulIdentifier", + "src": "24221:6:0" + }, + "nativeSrc": "24221:59:0", + "nodeType": "YulFunctionCall", + "src": "24221:59:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "24208:6:0", + "nodeType": "YulIdentifier", + "src": "24208:6:0" + }, + "nativeSrc": "24208:73:0", + "nodeType": "YulFunctionCall", + "src": "24208:73:0" + }, + "nativeSrc": "24208:73:0", + "nodeType": "YulExpressionStatement", + "src": "24208:73:0" + }, + { + "nativeSrc": "24302:46:0", + "nodeType": "YulAssignment", + "src": "24302:46:0", + "value": { + "arguments": [ + { + "name": "pow_of_omega", + "nativeSrc": "24325:12:0", + "nodeType": "YulIdentifier", + "src": "24325:12:0" + }, + { + "name": "omega", + "nativeSrc": "24339:5:0", + "nodeType": "YulIdentifier", + "src": "24339:5:0" + }, + { + "name": "r", + "nativeSrc": "24346:1:0", + "nodeType": "YulIdentifier", + "src": "24346:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "24318:6:0", + "nodeType": "YulIdentifier", + "src": "24318:6:0" + }, + "nativeSrc": "24318:30:0", + "nodeType": "YulFunctionCall", + "src": "24318:30:0" + }, + "variableNames": [ + { + "name": "pow_of_omega", + "nativeSrc": "24302:12:0", + "nodeType": "YulIdentifier", + "src": "24302:12:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "24106:4:0", + "nodeType": "YulIdentifier", + "src": "24106:4:0" + }, + { + "name": "mptr_end", + "nativeSrc": "24112:8:0", + "nodeType": "YulIdentifier", + "src": "24112:8:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "24103:2:0", + "nodeType": "YulIdentifier", + "src": "24103:2:0" + }, + "nativeSrc": "24103:18:0", + "nodeType": "YulFunctionCall", + "src": "24103:18:0" + }, + "nativeSrc": "24008:358:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "24142:27:0", + "nodeType": "YulBlock", + "src": "24142:27:0", + "statements": [ + { + "nativeSrc": "24144:23:0", + "nodeType": "YulAssignment", + "src": "24144:23:0", + "value": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "24156:4:0", + "nodeType": "YulIdentifier", + "src": "24156:4:0" + }, + { + "kind": "number", + "nativeSrc": "24162:4:0", + "nodeType": "YulLiteral", + "src": "24162:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "24152:3:0", + "nodeType": "YulIdentifier", + "src": "24152:3:0" + }, + "nativeSrc": "24152:15:0", + "nodeType": "YulFunctionCall", + "src": "24152:15:0" + }, + "variableNames": [ + { + "name": "mptr", + "nativeSrc": "24144:4:0", + "nodeType": "YulIdentifier", + "src": "24144:4:0" + } + ] + } + ] + }, + "pre": { + "nativeSrc": "24032:50:0", + "nodeType": "YulBlock", + "src": "24032:50:0", + "statements": [ + { + "nativeSrc": "24034:46:0", + "nodeType": "YulVariableDeclaration", + "src": "24034:46:0", + "value": { + "arguments": [ + { + "name": "OMEGA_INV_TO_L_MPTR", + "nativeSrc": "24060:19:0", + "nodeType": "YulIdentifier", + "src": "24060:19:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "24054:5:0", + "nodeType": "YulIdentifier", + "src": "24054:5:0" + }, + "nativeSrc": "24054:26:0", + "nodeType": "YulFunctionCall", + "src": "24054:26:0" + }, + "variables": [ + { + "name": "pow_of_omega", + "nativeSrc": "24038:12:0", + "nodeType": "YulTypedName", + "src": "24038:12:0", + "type": "" + } + ] + } + ] + }, + "src": "24008:358:0" + }, + { + "nativeSrc": "24384:41:0", + "nodeType": "YulVariableDeclaration", + "src": "24384:41:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "X_N_MPTR", + "nativeSrc": "24409:8:0", + "nodeType": "YulIdentifier", + "src": "24409:8:0" + }, + { + "kind": "number", + "nativeSrc": "24419:4:0", + "nodeType": "YulLiteral", + "src": "24419:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "24405:3:0", + "nodeType": "YulIdentifier", + "src": "24405:3:0" + }, + "nativeSrc": "24405:19:0", + "nodeType": "YulFunctionCall", + "src": "24405:19:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "24399:5:0", + "nodeType": "YulIdentifier", + "src": "24399:5:0" + }, + "nativeSrc": "24399:26:0", + "nodeType": "YulFunctionCall", + "src": "24399:26:0" + }, + "variables": [ + { + "name": "l_blind", + "nativeSrc": "24388:7:0", + "nodeType": "YulTypedName", + "src": "24388:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "24442:35:0", + "nodeType": "YulVariableDeclaration", + "src": "24442:35:0", + "value": { + "arguments": [ + { + "name": "X_N_MPTR", + "nativeSrc": "24462:8:0", + "nodeType": "YulIdentifier", + "src": "24462:8:0" + }, + { + "kind": "number", + "nativeSrc": "24472:4:0", + "nodeType": "YulLiteral", + "src": "24472:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "24458:3:0", + "nodeType": "YulIdentifier", + "src": "24458:3:0" + }, + "nativeSrc": "24458:19:0", + "nodeType": "YulFunctionCall", + "src": "24458:19:0" + }, + "variables": [ + { + "name": "l_i_cptr", + "nativeSrc": "24446:8:0", + "nodeType": "YulTypedName", + "src": "24446:8:0", + "type": "" + } + ] + }, + { + "body": { + "nativeSrc": "24681:86:0", + "nodeType": "YulBlock", + "src": "24681:86:0", + "statements": [ + { + "nativeSrc": "24703:46:0", + "nodeType": "YulAssignment", + "src": "24703:46:0", + "value": { + "arguments": [ + { + "name": "l_blind", + "nativeSrc": "24721:7:0", + "nodeType": "YulIdentifier", + "src": "24721:7:0" + }, + { + "arguments": [ + { + "name": "l_i_cptr", + "nativeSrc": "24736:8:0", + "nodeType": "YulIdentifier", + "src": "24736:8:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "24730:5:0", + "nodeType": "YulIdentifier", + "src": "24730:5:0" + }, + "nativeSrc": "24730:15:0", + "nodeType": "YulFunctionCall", + "src": "24730:15:0" + }, + { + "name": "r", + "nativeSrc": "24747:1:0", + "nodeType": "YulIdentifier", + "src": "24747:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "24714:6:0", + "nodeType": "YulIdentifier", + "src": "24714:6:0" + }, + "nativeSrc": "24714:35:0", + "nodeType": "YulFunctionCall", + "src": "24714:35:0" + }, + "variableNames": [ + { + "name": "l_blind", + "nativeSrc": "24703:7:0", + "nodeType": "YulIdentifier", + "src": "24703:7:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "l_i_cptr", + "nativeSrc": "24585:8:0", + "nodeType": "YulIdentifier", + "src": "24585:8:0" + }, + { + "name": "l_i_cptr_end", + "nativeSrc": "24595:12:0", + "nodeType": "YulIdentifier", + "src": "24595:12:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "24582:2:0", + "nodeType": "YulIdentifier", + "src": "24582:2:0" + }, + "nativeSrc": "24582:26:0", + "nodeType": "YulFunctionCall", + "src": "24582:26:0" + }, + "nativeSrc": "24494:273:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "24629:35:0", + "nodeType": "YulBlock", + "src": "24629:35:0", + "statements": [ + { + "nativeSrc": "24631:31:0", + "nodeType": "YulAssignment", + "src": "24631:31:0", + "value": { + "arguments": [ + { + "name": "l_i_cptr", + "nativeSrc": "24647:8:0", + "nodeType": "YulIdentifier", + "src": "24647:8:0" + }, + { + "kind": "number", + "nativeSrc": "24657:4:0", + "nodeType": "YulLiteral", + "src": "24657:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "24643:3:0", + "nodeType": "YulIdentifier", + "src": "24643:3:0" + }, + "nativeSrc": "24643:19:0", + "nodeType": "YulFunctionCall", + "src": "24643:19:0" + }, + "variableNames": [ + { + "name": "l_i_cptr", + "nativeSrc": "24631:8:0", + "nodeType": "YulIdentifier", + "src": "24631:8:0" + } + ] + } + ] + }, + "pre": { + "nativeSrc": "24518:43:0", + "nodeType": "YulBlock", + "src": "24518:43:0", + "statements": [ + { + "nativeSrc": "24520:39:0", + "nodeType": "YulVariableDeclaration", + "src": "24520:39:0", + "value": { + "arguments": [ + { + "name": "X_N_MPTR", + "nativeSrc": "24544:8:0", + "nodeType": "YulIdentifier", + "src": "24544:8:0" + }, + { + "kind": "number", + "nativeSrc": "24554:4:0", + "nodeType": "YulLiteral", + "src": "24554:4:0", + "type": "", + "value": "0xc0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "24540:3:0", + "nodeType": "YulIdentifier", + "src": "24540:3:0" + }, + "nativeSrc": "24540:19:0", + "nodeType": "YulFunctionCall", + "src": "24540:19:0" + }, + "variables": [ + { + "name": "l_i_cptr_end", + "nativeSrc": "24524:12:0", + "nodeType": "YulTypedName", + "src": "24524:12:0", + "type": "" + } + ] + } + ] + }, + "src": "24494:273:0" + }, + { + "nativeSrc": "24785:76:0", + "nodeType": "YulVariableDeclaration", + "src": "24785:76:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "l_i_cptr", + "nativeSrc": "24819:8:0", + "nodeType": "YulIdentifier", + "src": "24819:8:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "24813:5:0", + "nodeType": "YulIdentifier", + "src": "24813:5:0" + }, + "nativeSrc": "24813:15:0", + "nodeType": "YulFunctionCall", + "src": "24813:15:0" + }, + { + "arguments": [ + { + "name": "INSTANCE_CPTR", + "nativeSrc": "24843:13:0", + "nodeType": "YulIdentifier", + "src": "24843:13:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "24830:12:0", + "nodeType": "YulIdentifier", + "src": "24830:12:0" + }, + "nativeSrc": "24830:27:0", + "nodeType": "YulFunctionCall", + "src": "24830:27:0" + }, + { + "name": "r", + "nativeSrc": "24859:1:0", + "nodeType": "YulIdentifier", + "src": "24859:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "24806:6:0", + "nodeType": "YulIdentifier", + "src": "24806:6:0" + }, + "nativeSrc": "24806:55:0", + "nodeType": "YulFunctionCall", + "src": "24806:55:0" + }, + "variables": [ + { + "name": "instance_eval", + "nativeSrc": "24789:13:0", + "nodeType": "YulTypedName", + "src": "24789:13:0", + "type": "" + } + ] + }, + { + "nativeSrc": "24878:45:0", + "nodeType": "YulVariableDeclaration", + "src": "24878:45:0", + "value": { + "arguments": [ + { + "name": "INSTANCE_CPTR", + "nativeSrc": "24903:13:0", + "nodeType": "YulIdentifier", + "src": "24903:13:0" + }, + { + "kind": "number", + "nativeSrc": "24918:4:0", + "nodeType": "YulLiteral", + "src": "24918:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "24899:3:0", + "nodeType": "YulIdentifier", + "src": "24899:3:0" + }, + "nativeSrc": "24899:24:0", + "nodeType": "YulFunctionCall", + "src": "24899:24:0" + }, + "variables": [ + { + "name": "instance_cptr", + "nativeSrc": "24882:13:0", + "nodeType": "YulTypedName", + "src": "24882:13:0", + "type": "" + } + ] + }, + { + "nativeSrc": "24940:31:0", + "nodeType": "YulAssignment", + "src": "24940:31:0", + "value": { + "arguments": [ + { + "name": "l_i_cptr", + "nativeSrc": "24956:8:0", + "nodeType": "YulIdentifier", + "src": "24956:8:0" + }, + { + "kind": "number", + "nativeSrc": "24966:4:0", + "nodeType": "YulLiteral", + "src": "24966:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "24952:3:0", + "nodeType": "YulIdentifier", + "src": "24952:3:0" + }, + "nativeSrc": "24952:19:0", + "nodeType": "YulFunctionCall", + "src": "24952:19:0" + }, + "variableNames": [ + { + "name": "l_i_cptr", + "nativeSrc": "24940:8:0", + "nodeType": "YulIdentifier", + "src": "24940:8:0" + } + ] + }, + { + "body": { + "nativeSrc": "25337:138:0", + "nodeType": "YulBlock", + "src": "25337:138:0", + "statements": [ + { + "nativeSrc": "25359:98:0", + "nodeType": "YulAssignment", + "src": "25359:98:0", + "value": { + "arguments": [ + { + "name": "instance_eval", + "nativeSrc": "25383:13:0", + "nodeType": "YulIdentifier", + "src": "25383:13:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "l_i_cptr", + "nativeSrc": "25411:8:0", + "nodeType": "YulIdentifier", + "src": "25411:8:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "25405:5:0", + "nodeType": "YulIdentifier", + "src": "25405:5:0" + }, + "nativeSrc": "25405:15:0", + "nodeType": "YulFunctionCall", + "src": "25405:15:0" + }, + { + "arguments": [ + { + "name": "instance_cptr", + "nativeSrc": "25435:13:0", + "nodeType": "YulIdentifier", + "src": "25435:13:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "25422:12:0", + "nodeType": "YulIdentifier", + "src": "25422:12:0" + }, + "nativeSrc": "25422:27:0", + "nodeType": "YulFunctionCall", + "src": "25422:27:0" + }, + { + "name": "r", + "nativeSrc": "25451:1:0", + "nodeType": "YulIdentifier", + "src": "25451:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "25398:6:0", + "nodeType": "YulIdentifier", + "src": "25398:6:0" + }, + "nativeSrc": "25398:55:0", + "nodeType": "YulFunctionCall", + "src": "25398:55:0" + }, + { + "name": "r", + "nativeSrc": "25455:1:0", + "nodeType": "YulIdentifier", + "src": "25455:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "25376:6:0", + "nodeType": "YulIdentifier", + "src": "25376:6:0" + }, + "nativeSrc": "25376:81:0", + "nodeType": "YulFunctionCall", + "src": "25376:81:0" + }, + "variableNames": [ + { + "name": "instance_eval", + "nativeSrc": "25359:13:0", + "nodeType": "YulIdentifier", + "src": "25359:13:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "instance_cptr", + "nativeSrc": "25121:13:0", + "nodeType": "YulIdentifier", + "src": "25121:13:0" + }, + { + "name": "instance_cptr_end", + "nativeSrc": "25136:17:0", + "nodeType": "YulIdentifier", + "src": "25136:17:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "25118:2:0", + "nodeType": "YulIdentifier", + "src": "25118:2:0" + }, + "nativeSrc": "25118:36:0", + "nodeType": "YulFunctionCall", + "src": "25118:36:0" + }, + "nativeSrc": "24988:487:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "25175:145:0", + "nodeType": "YulBlock", + "src": "25175:145:0", + "statements": [ + { + "nativeSrc": "25201:41:0", + "nodeType": "YulAssignment", + "src": "25201:41:0", + "value": { + "arguments": [ + { + "name": "instance_cptr", + "nativeSrc": "25222:13:0", + "nodeType": "YulIdentifier", + "src": "25222:13:0" + }, + { + "kind": "number", + "nativeSrc": "25237:4:0", + "nodeType": "YulLiteral", + "src": "25237:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "25218:3:0", + "nodeType": "YulIdentifier", + "src": "25218:3:0" + }, + "nativeSrc": "25218:24:0", + "nodeType": "YulFunctionCall", + "src": "25218:24:0" + }, + "variableNames": [ + { + "name": "instance_cptr", + "nativeSrc": "25201:13:0", + "nodeType": "YulIdentifier", + "src": "25201:13:0" + } + ] + }, + { + "nativeSrc": "25267:31:0", + "nodeType": "YulAssignment", + "src": "25267:31:0", + "value": { + "arguments": [ + { + "name": "l_i_cptr", + "nativeSrc": "25283:8:0", + "nodeType": "YulIdentifier", + "src": "25283:8:0" + }, + { + "kind": "number", + "nativeSrc": "25293:4:0", + "nodeType": "YulLiteral", + "src": "25293:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "25279:3:0", + "nodeType": "YulIdentifier", + "src": "25279:3:0" + }, + "nativeSrc": "25279:19:0", + "nodeType": "YulFunctionCall", + "src": "25279:19:0" + }, + "variableNames": [ + { + "name": "l_i_cptr", + "nativeSrc": "25267:8:0", + "nodeType": "YulIdentifier", + "src": "25267:8:0" + } + ] + } + ] + }, + "pre": { + "nativeSrc": "25012:85:0", + "nodeType": "YulBlock", + "src": "25012:85:0", + "statements": [ + { + "nativeSrc": "25014:81:0", + "nodeType": "YulVariableDeclaration", + "src": "25014:81:0", + "value": { + "arguments": [ + { + "name": "INSTANCE_CPTR", + "nativeSrc": "25043:13:0", + "nodeType": "YulIdentifier", + "src": "25043:13:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "25062:4:0", + "nodeType": "YulLiteral", + "src": "25062:4:0", + "type": "", + "value": "0x20" + }, + { + "arguments": [ + { + "name": "NUM_INSTANCES_MPTR", + "nativeSrc": "25074:18:0", + "nodeType": "YulIdentifier", + "src": "25074:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "25068:5:0", + "nodeType": "YulIdentifier", + "src": "25068:5:0" + }, + "nativeSrc": "25068:25:0", + "nodeType": "YulFunctionCall", + "src": "25068:25:0" + } + ], + "functionName": { + "name": "mul", + "nativeSrc": "25058:3:0", + "nodeType": "YulIdentifier", + "src": "25058:3:0" + }, + "nativeSrc": "25058:36:0", + "nodeType": "YulFunctionCall", + "src": "25058:36:0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "25039:3:0", + "nodeType": "YulIdentifier", + "src": "25039:3:0" + }, + "nativeSrc": "25039:56:0", + "nodeType": "YulFunctionCall", + "src": "25039:56:0" + }, + "variables": [ + { + "name": "instance_cptr_end", + "nativeSrc": "25018:17:0", + "nodeType": "YulTypedName", + "src": "25018:17:0", + "type": "" + } + ] + } + ] + }, + "src": "24988:487:0" + }, + { + "nativeSrc": "25493:38:0", + "nodeType": "YulVariableDeclaration", + "src": "25493:38:0", + "value": { + "arguments": [ + { + "name": "mptr_end", + "nativeSrc": "25522:8:0", + "nodeType": "YulIdentifier", + "src": "25522:8:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "25516:5:0", + "nodeType": "YulIdentifier", + "src": "25516:5:0" + }, + "nativeSrc": "25516:15:0", + "nodeType": "YulFunctionCall", + "src": "25516:15:0" + }, + "variables": [ + { + "name": "x_n_minus_1_inv", + "nativeSrc": "25497:15:0", + "nodeType": "YulTypedName", + "src": "25497:15:0", + "type": "" + } + ] + }, + { + "nativeSrc": "25548:29:0", + "nodeType": "YulVariableDeclaration", + "src": "25548:29:0", + "value": { + "arguments": [ + { + "name": "X_N_MPTR", + "nativeSrc": "25568:8:0", + "nodeType": "YulIdentifier", + "src": "25568:8:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "25562:5:0", + "nodeType": "YulIdentifier", + "src": "25562:5:0" + }, + "nativeSrc": "25562:15:0", + "nodeType": "YulFunctionCall", + "src": "25562:15:0" + }, + "variables": [ + { + "name": "l_last", + "nativeSrc": "25552:6:0", + "nodeType": "YulTypedName", + "src": "25552:6:0", + "type": "" + } + ] + }, + { + "nativeSrc": "25594:37:0", + "nodeType": "YulVariableDeclaration", + "src": "25594:37:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "X_N_MPTR", + "nativeSrc": "25615:8:0", + "nodeType": "YulIdentifier", + "src": "25615:8:0" + }, + { + "kind": "number", + "nativeSrc": "25625:4:0", + "nodeType": "YulLiteral", + "src": "25625:4:0", + "type": "", + "value": "0xc0" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "25611:3:0", + "nodeType": "YulIdentifier", + "src": "25611:3:0" + }, + "nativeSrc": "25611:19:0", + "nodeType": "YulFunctionCall", + "src": "25611:19:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "25605:5:0", + "nodeType": "YulIdentifier", + "src": "25605:5:0" + }, + "nativeSrc": "25605:26:0", + "nodeType": "YulFunctionCall", + "src": "25605:26:0" + }, + "variables": [ + { + "name": "l_0", + "nativeSrc": "25598:3:0", + "nodeType": "YulTypedName", + "src": "25598:3:0", + "type": "" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "X_N_MPTR", + "nativeSrc": "25656:8:0", + "nodeType": "YulIdentifier", + "src": "25656:8:0" + }, + { + "name": "x_n", + "nativeSrc": "25666:3:0", + "nodeType": "YulIdentifier", + "src": "25666:3:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "25649:6:0", + "nodeType": "YulIdentifier", + "src": "25649:6:0" + }, + "nativeSrc": "25649:21:0", + "nodeType": "YulFunctionCall", + "src": "25649:21:0" + }, + "nativeSrc": "25649:21:0", + "nodeType": "YulExpressionStatement", + "src": "25649:21:0" + }, + { + "expression": { + "arguments": [ + { + "name": "X_N_MINUS_1_INV_MPTR", + "nativeSrc": "25694:20:0", + "nodeType": "YulIdentifier", + "src": "25694:20:0" + }, + { + "name": "x_n_minus_1_inv", + "nativeSrc": "25716:15:0", + "nodeType": "YulIdentifier", + "src": "25716:15:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "25687:6:0", + "nodeType": "YulIdentifier", + "src": "25687:6:0" + }, + "nativeSrc": "25687:45:0", + "nodeType": "YulFunctionCall", + "src": "25687:45:0" + }, + "nativeSrc": "25687:45:0", + "nodeType": "YulExpressionStatement", + "src": "25687:45:0" + }, + { + "expression": { + "arguments": [ + { + "name": "L_LAST_MPTR", + "nativeSrc": "25756:11:0", + "nodeType": "YulIdentifier", + "src": "25756:11:0" + }, + { + "name": "l_last", + "nativeSrc": "25769:6:0", + "nodeType": "YulIdentifier", + "src": "25769:6:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "25749:6:0", + "nodeType": "YulIdentifier", + "src": "25749:6:0" + }, + "nativeSrc": "25749:27:0", + "nodeType": "YulFunctionCall", + "src": "25749:27:0" + }, + "nativeSrc": "25749:27:0", + "nodeType": "YulExpressionStatement", + "src": "25749:27:0" + }, + { + "expression": { + "arguments": [ + { + "name": "L_BLIND_MPTR", + "nativeSrc": "25800:12:0", + "nodeType": "YulIdentifier", + "src": "25800:12:0" + }, + { + "name": "l_blind", + "nativeSrc": "25814:7:0", + "nodeType": "YulIdentifier", + "src": "25814:7:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "25793:6:0", + "nodeType": "YulIdentifier", + "src": "25793:6:0" + }, + "nativeSrc": "25793:29:0", + "nodeType": "YulFunctionCall", + "src": "25793:29:0" + }, + "nativeSrc": "25793:29:0", + "nodeType": "YulExpressionStatement", + "src": "25793:29:0" + }, + { + "expression": { + "arguments": [ + { + "name": "L_0_MPTR", + "nativeSrc": "25846:8:0", + "nodeType": "YulIdentifier", + "src": "25846:8:0" + }, + { + "name": "l_0", + "nativeSrc": "25856:3:0", + "nodeType": "YulIdentifier", + "src": "25856:3:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "25839:6:0", + "nodeType": "YulIdentifier", + "src": "25839:6:0" + }, + "nativeSrc": "25839:21:0", + "nodeType": "YulFunctionCall", + "src": "25839:21:0" + }, + "nativeSrc": "25839:21:0", + "nodeType": "YulExpressionStatement", + "src": "25839:21:0" + }, + { + "expression": { + "arguments": [ + { + "name": "INSTANCE_EVAL_MPTR", + "nativeSrc": "25884:18:0", + "nodeType": "YulIdentifier", + "src": "25884:18:0" + }, + { + "name": "instance_eval", + "nativeSrc": "25904:13:0", + "nodeType": "YulIdentifier", + "src": "25904:13:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "25877:6:0", + "nodeType": "YulIdentifier", + "src": "25877:6:0" + }, + "nativeSrc": "25877:41:0", + "nodeType": "YulFunctionCall", + "src": "25877:41:0" + }, + "nativeSrc": "25877:41:0", + "nodeType": "YulExpressionStatement", + "src": "25877:41:0" + } + ] + }, + { + "nativeSrc": "25990:19440:0", + "nodeType": "YulBlock", + "src": "25990:19440:0", + "statements": [ + { + "nativeSrc": "26008:23:0", + "nodeType": "YulVariableDeclaration", + "src": "26008:23:0", + "variables": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "26012:19:0", + "nodeType": "YulTypedName", + "src": "26012:19:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26048:89:0", + "nodeType": "YulVariableDeclaration", + "src": "26048:89:0", + "value": { + "kind": "number", + "nativeSrc": "26061:76:0", + "nodeType": "YulLiteral", + "src": "26061:76:0", + "type": "", + "value": "4131629893567559867359510883348571134090853742863529169391034518566172092834" + }, + "variables": [ + { + "name": "delta", + "nativeSrc": "26052:5:0", + "nodeType": "YulTypedName", + "src": "26052:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26154:22:0", + "nodeType": "YulVariableDeclaration", + "src": "26154:22:0", + "value": { + "arguments": [ + { + "name": "Y_MPTR", + "nativeSrc": "26169:6:0", + "nodeType": "YulIdentifier", + "src": "26169:6:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "26163:5:0", + "nodeType": "YulIdentifier", + "src": "26163:5:0" + }, + "nativeSrc": "26163:13:0", + "nodeType": "YulFunctionCall", + "src": "26163:13:0" + }, + "variables": [ + { + "name": "y", + "nativeSrc": "26158:1:0", + "nodeType": "YulTypedName", + "src": "26158:1:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26193:933:0", + "nodeType": "YulBlock", + "src": "26193:933:0", + "statements": [ + { + "nativeSrc": "26215:31:0", + "nodeType": "YulVariableDeclaration", + "src": "26215:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "26239:6:0", + "nodeType": "YulLiteral", + "src": "26239:6:0", + "type": "", + "value": "0x05e4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "26226:12:0", + "nodeType": "YulIdentifier", + "src": "26226:12:0" + }, + "nativeSrc": "26226:20:0", + "nodeType": "YulFunctionCall", + "src": "26226:20:0" + }, + "variables": [ + { + "name": "f_8", + "nativeSrc": "26219:3:0", + "nodeType": "YulTypedName", + "src": "26219:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26267:15:0", + "nodeType": "YulVariableDeclaration", + "src": "26267:15:0", + "value": { + "kind": "number", + "nativeSrc": "26279:3:0", + "nodeType": "YulLiteral", + "src": "26279:3:0", + "type": "", + "value": "0x1" + }, + "variables": [ + { + "name": "var0", + "nativeSrc": "26271:4:0", + "nodeType": "YulTypedName", + "src": "26271:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26303:23:0", + "nodeType": "YulVariableDeclaration", + "src": "26303:23:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "26319:1:0", + "nodeType": "YulIdentifier", + "src": "26319:1:0" + }, + { + "name": "f_8", + "nativeSrc": "26322:3:0", + "nodeType": "YulIdentifier", + "src": "26322:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "26315:3:0", + "nodeType": "YulIdentifier", + "src": "26315:3:0" + }, + "nativeSrc": "26315:11:0", + "nodeType": "YulFunctionCall", + "src": "26315:11:0" + }, + "variables": [ + { + "name": "var1", + "nativeSrc": "26307:4:0", + "nodeType": "YulTypedName", + "src": "26307:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26347:33:0", + "nodeType": "YulVariableDeclaration", + "src": "26347:33:0", + "value": { + "arguments": [ + { + "name": "var0", + "nativeSrc": "26366:4:0", + "nodeType": "YulIdentifier", + "src": "26366:4:0" + }, + { + "name": "var1", + "nativeSrc": "26372:4:0", + "nodeType": "YulIdentifier", + "src": "26372:4:0" + }, + { + "name": "r", + "nativeSrc": "26378:1:0", + "nodeType": "YulIdentifier", + "src": "26378:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "26359:6:0", + "nodeType": "YulIdentifier", + "src": "26359:6:0" + }, + "nativeSrc": "26359:21:0", + "nodeType": "YulFunctionCall", + "src": "26359:21:0" + }, + "variables": [ + { + "name": "var2", + "nativeSrc": "26351:4:0", + "nodeType": "YulTypedName", + "src": "26351:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26401:32:0", + "nodeType": "YulVariableDeclaration", + "src": "26401:32:0", + "value": { + "arguments": [ + { + "name": "f_8", + "nativeSrc": "26420:3:0", + "nodeType": "YulIdentifier", + "src": "26420:3:0" + }, + { + "name": "var2", + "nativeSrc": "26425:4:0", + "nodeType": "YulIdentifier", + "src": "26425:4:0" + }, + { + "name": "r", + "nativeSrc": "26431:1:0", + "nodeType": "YulIdentifier", + "src": "26431:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "26413:6:0", + "nodeType": "YulIdentifier", + "src": "26413:6:0" + }, + "nativeSrc": "26413:20:0", + "nodeType": "YulFunctionCall", + "src": "26413:20:0" + }, + "variables": [ + { + "name": "var3", + "nativeSrc": "26405:4:0", + "nodeType": "YulTypedName", + "src": "26405:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26454:15:0", + "nodeType": "YulVariableDeclaration", + "src": "26454:15:0", + "value": { + "kind": "number", + "nativeSrc": "26466:3:0", + "nodeType": "YulLiteral", + "src": "26466:3:0", + "type": "", + "value": "0x2" + }, + "variables": [ + { + "name": "var4", + "nativeSrc": "26458:4:0", + "nodeType": "YulTypedName", + "src": "26458:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26490:33:0", + "nodeType": "YulVariableDeclaration", + "src": "26490:33:0", + "value": { + "arguments": [ + { + "name": "var4", + "nativeSrc": "26509:4:0", + "nodeType": "YulIdentifier", + "src": "26509:4:0" + }, + { + "name": "var1", + "nativeSrc": "26515:4:0", + "nodeType": "YulIdentifier", + "src": "26515:4:0" + }, + { + "name": "r", + "nativeSrc": "26521:1:0", + "nodeType": "YulIdentifier", + "src": "26521:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "26502:6:0", + "nodeType": "YulIdentifier", + "src": "26502:6:0" + }, + "nativeSrc": "26502:21:0", + "nodeType": "YulFunctionCall", + "src": "26502:21:0" + }, + "variables": [ + { + "name": "var5", + "nativeSrc": "26494:4:0", + "nodeType": "YulTypedName", + "src": "26494:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26544:33:0", + "nodeType": "YulVariableDeclaration", + "src": "26544:33:0", + "value": { + "arguments": [ + { + "name": "var3", + "nativeSrc": "26563:4:0", + "nodeType": "YulIdentifier", + "src": "26563:4:0" + }, + { + "name": "var5", + "nativeSrc": "26569:4:0", + "nodeType": "YulIdentifier", + "src": "26569:4:0" + }, + { + "name": "r", + "nativeSrc": "26575:1:0", + "nodeType": "YulIdentifier", + "src": "26575:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "26556:6:0", + "nodeType": "YulIdentifier", + "src": "26556:6:0" + }, + "nativeSrc": "26556:21:0", + "nodeType": "YulFunctionCall", + "src": "26556:21:0" + }, + "variables": [ + { + "name": "var6", + "nativeSrc": "26548:4:0", + "nodeType": "YulTypedName", + "src": "26548:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26598:31:0", + "nodeType": "YulVariableDeclaration", + "src": "26598:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "26622:6:0", + "nodeType": "YulLiteral", + "src": "26622:6:0", + "type": "", + "value": "0x04a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "26609:12:0", + "nodeType": "YulIdentifier", + "src": "26609:12:0" + }, + "nativeSrc": "26609:20:0", + "nodeType": "YulFunctionCall", + "src": "26609:20:0" + }, + "variables": [ + { + "name": "a_2", + "nativeSrc": "26602:3:0", + "nodeType": "YulTypedName", + "src": "26602:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26650:31:0", + "nodeType": "YulVariableDeclaration", + "src": "26650:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "26674:6:0", + "nodeType": "YulLiteral", + "src": "26674:6:0", + "type": "", + "value": "0x0464" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "26661:12:0", + "nodeType": "YulIdentifier", + "src": "26661:12:0" + }, + "nativeSrc": "26661:20:0", + "nodeType": "YulFunctionCall", + "src": "26661:20:0" + }, + "variables": [ + { + "name": "a_0", + "nativeSrc": "26654:3:0", + "nodeType": "YulTypedName", + "src": "26654:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26702:31:0", + "nodeType": "YulVariableDeclaration", + "src": "26702:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "26726:6:0", + "nodeType": "YulLiteral", + "src": "26726:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "26713:12:0", + "nodeType": "YulIdentifier", + "src": "26713:12:0" + }, + "nativeSrc": "26713:20:0", + "nodeType": "YulFunctionCall", + "src": "26713:20:0" + }, + "variables": [ + { + "name": "a_1", + "nativeSrc": "26706:3:0", + "nodeType": "YulTypedName", + "src": "26706:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26754:31:0", + "nodeType": "YulVariableDeclaration", + "src": "26754:31:0", + "value": { + "arguments": [ + { + "name": "a_0", + "nativeSrc": "26773:3:0", + "nodeType": "YulIdentifier", + "src": "26773:3:0" + }, + { + "name": "a_1", + "nativeSrc": "26778:3:0", + "nodeType": "YulIdentifier", + "src": "26778:3:0" + }, + { + "name": "r", + "nativeSrc": "26783:1:0", + "nodeType": "YulIdentifier", + "src": "26783:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "26766:6:0", + "nodeType": "YulIdentifier", + "src": "26766:6:0" + }, + "nativeSrc": "26766:19:0", + "nodeType": "YulFunctionCall", + "src": "26766:19:0" + }, + "variables": [ + { + "name": "var7", + "nativeSrc": "26758:4:0", + "nodeType": "YulTypedName", + "src": "26758:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26806:38:0", + "nodeType": "YulVariableDeclaration", + "src": "26806:38:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "26837:6:0", + "nodeType": "YulLiteral", + "src": "26837:6:0", + "type": "", + "value": "0x04c4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "26824:12:0", + "nodeType": "YulIdentifier", + "src": "26824:12:0" + }, + "nativeSrc": "26824:20:0", + "nodeType": "YulFunctionCall", + "src": "26824:20:0" + }, + "variables": [ + { + "name": "a_2_prev_1", + "nativeSrc": "26810:10:0", + "nodeType": "YulTypedName", + "src": "26810:10:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26865:39:0", + "nodeType": "YulVariableDeclaration", + "src": "26865:39:0", + "value": { + "arguments": [ + { + "name": "var7", + "nativeSrc": "26884:4:0", + "nodeType": "YulIdentifier", + "src": "26884:4:0" + }, + { + "name": "a_2_prev_1", + "nativeSrc": "26890:10:0", + "nodeType": "YulIdentifier", + "src": "26890:10:0" + }, + { + "name": "r", + "nativeSrc": "26902:1:0", + "nodeType": "YulIdentifier", + "src": "26902:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "26877:6:0", + "nodeType": "YulIdentifier", + "src": "26877:6:0" + }, + "nativeSrc": "26877:27:0", + "nodeType": "YulFunctionCall", + "src": "26877:27:0" + }, + "variables": [ + { + "name": "var8", + "nativeSrc": "26869:4:0", + "nodeType": "YulTypedName", + "src": "26869:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26925:24:0", + "nodeType": "YulVariableDeclaration", + "src": "26925:24:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "26941:1:0", + "nodeType": "YulIdentifier", + "src": "26941:1:0" + }, + { + "name": "var8", + "nativeSrc": "26944:4:0", + "nodeType": "YulIdentifier", + "src": "26944:4:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "26937:3:0", + "nodeType": "YulIdentifier", + "src": "26937:3:0" + }, + "nativeSrc": "26937:12:0", + "nodeType": "YulFunctionCall", + "src": "26937:12:0" + }, + "variables": [ + { + "name": "var9", + "nativeSrc": "26929:4:0", + "nodeType": "YulTypedName", + "src": "26929:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "26970:33:0", + "nodeType": "YulVariableDeclaration", + "src": "26970:33:0", + "value": { + "arguments": [ + { + "name": "a_2", + "nativeSrc": "26990:3:0", + "nodeType": "YulIdentifier", + "src": "26990:3:0" + }, + { + "name": "var9", + "nativeSrc": "26995:4:0", + "nodeType": "YulIdentifier", + "src": "26995:4:0" + }, + { + "name": "r", + "nativeSrc": "27001:1:0", + "nodeType": "YulIdentifier", + "src": "27001:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "26983:6:0", + "nodeType": "YulIdentifier", + "src": "26983:6:0" + }, + "nativeSrc": "26983:20:0", + "nodeType": "YulFunctionCall", + "src": "26983:20:0" + }, + "variables": [ + { + "name": "var10", + "nativeSrc": "26974:5:0", + "nodeType": "YulTypedName", + "src": "26974:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27024:35:0", + "nodeType": "YulVariableDeclaration", + "src": "27024:35:0", + "value": { + "arguments": [ + { + "name": "var6", + "nativeSrc": "27044:4:0", + "nodeType": "YulIdentifier", + "src": "27044:4:0" + }, + { + "name": "var10", + "nativeSrc": "27050:5:0", + "nodeType": "YulIdentifier", + "src": "27050:5:0" + }, + { + "name": "r", + "nativeSrc": "27057:1:0", + "nodeType": "YulIdentifier", + "src": "27057:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "27037:6:0", + "nodeType": "YulIdentifier", + "src": "27037:6:0" + }, + "nativeSrc": "27037:22:0", + "nodeType": "YulFunctionCall", + "src": "27037:22:0" + }, + "variables": [ + { + "name": "var11", + "nativeSrc": "27028:5:0", + "nodeType": "YulTypedName", + "src": "27028:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27080:28:0", + "nodeType": "YulAssignment", + "src": "27080:28:0", + "value": { + "name": "var11", + "nativeSrc": "27103:5:0", + "nodeType": "YulIdentifier", + "src": "27103:5:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "27080:19:0", + "nodeType": "YulIdentifier", + "src": "27080:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "27143:872:0", + "nodeType": "YulBlock", + "src": "27143:872:0", + "statements": [ + { + "nativeSrc": "27165:31:0", + "nodeType": "YulVariableDeclaration", + "src": "27165:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "27189:6:0", + "nodeType": "YulLiteral", + "src": "27189:6:0", + "type": "", + "value": "0x0604" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "27176:12:0", + "nodeType": "YulIdentifier", + "src": "27176:12:0" + }, + "nativeSrc": "27176:20:0", + "nodeType": "YulFunctionCall", + "src": "27176:20:0" + }, + "variables": [ + { + "name": "f_9", + "nativeSrc": "27169:3:0", + "nodeType": "YulTypedName", + "src": "27169:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27217:15:0", + "nodeType": "YulVariableDeclaration", + "src": "27217:15:0", + "value": { + "kind": "number", + "nativeSrc": "27229:3:0", + "nodeType": "YulLiteral", + "src": "27229:3:0", + "type": "", + "value": "0x2" + }, + "variables": [ + { + "name": "var0", + "nativeSrc": "27221:4:0", + "nodeType": "YulTypedName", + "src": "27221:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27253:23:0", + "nodeType": "YulVariableDeclaration", + "src": "27253:23:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "27269:1:0", + "nodeType": "YulIdentifier", + "src": "27269:1:0" + }, + { + "name": "f_9", + "nativeSrc": "27272:3:0", + "nodeType": "YulIdentifier", + "src": "27272:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "27265:3:0", + "nodeType": "YulIdentifier", + "src": "27265:3:0" + }, + "nativeSrc": "27265:11:0", + "nodeType": "YulFunctionCall", + "src": "27265:11:0" + }, + "variables": [ + { + "name": "var1", + "nativeSrc": "27257:4:0", + "nodeType": "YulTypedName", + "src": "27257:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27297:33:0", + "nodeType": "YulVariableDeclaration", + "src": "27297:33:0", + "value": { + "arguments": [ + { + "name": "var0", + "nativeSrc": "27316:4:0", + "nodeType": "YulIdentifier", + "src": "27316:4:0" + }, + { + "name": "var1", + "nativeSrc": "27322:4:0", + "nodeType": "YulIdentifier", + "src": "27322:4:0" + }, + { + "name": "r", + "nativeSrc": "27328:1:0", + "nodeType": "YulIdentifier", + "src": "27328:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "27309:6:0", + "nodeType": "YulIdentifier", + "src": "27309:6:0" + }, + "nativeSrc": "27309:21:0", + "nodeType": "YulFunctionCall", + "src": "27309:21:0" + }, + "variables": [ + { + "name": "var2", + "nativeSrc": "27301:4:0", + "nodeType": "YulTypedName", + "src": "27301:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27351:32:0", + "nodeType": "YulVariableDeclaration", + "src": "27351:32:0", + "value": { + "arguments": [ + { + "name": "f_9", + "nativeSrc": "27370:3:0", + "nodeType": "YulIdentifier", + "src": "27370:3:0" + }, + { + "name": "var2", + "nativeSrc": "27375:4:0", + "nodeType": "YulIdentifier", + "src": "27375:4:0" + }, + { + "name": "r", + "nativeSrc": "27381:1:0", + "nodeType": "YulIdentifier", + "src": "27381:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "27363:6:0", + "nodeType": "YulIdentifier", + "src": "27363:6:0" + }, + "nativeSrc": "27363:20:0", + "nodeType": "YulFunctionCall", + "src": "27363:20:0" + }, + "variables": [ + { + "name": "var3", + "nativeSrc": "27355:4:0", + "nodeType": "YulTypedName", + "src": "27355:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27404:15:0", + "nodeType": "YulVariableDeclaration", + "src": "27404:15:0", + "value": { + "kind": "number", + "nativeSrc": "27416:3:0", + "nodeType": "YulLiteral", + "src": "27416:3:0", + "type": "", + "value": "0x3" + }, + "variables": [ + { + "name": "var4", + "nativeSrc": "27408:4:0", + "nodeType": "YulTypedName", + "src": "27408:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27440:33:0", + "nodeType": "YulVariableDeclaration", + "src": "27440:33:0", + "value": { + "arguments": [ + { + "name": "var4", + "nativeSrc": "27459:4:0", + "nodeType": "YulIdentifier", + "src": "27459:4:0" + }, + { + "name": "var1", + "nativeSrc": "27465:4:0", + "nodeType": "YulIdentifier", + "src": "27465:4:0" + }, + { + "name": "r", + "nativeSrc": "27471:1:0", + "nodeType": "YulIdentifier", + "src": "27471:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "27452:6:0", + "nodeType": "YulIdentifier", + "src": "27452:6:0" + }, + "nativeSrc": "27452:21:0", + "nodeType": "YulFunctionCall", + "src": "27452:21:0" + }, + "variables": [ + { + "name": "var5", + "nativeSrc": "27444:4:0", + "nodeType": "YulTypedName", + "src": "27444:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27494:33:0", + "nodeType": "YulVariableDeclaration", + "src": "27494:33:0", + "value": { + "arguments": [ + { + "name": "var3", + "nativeSrc": "27513:4:0", + "nodeType": "YulIdentifier", + "src": "27513:4:0" + }, + { + "name": "var5", + "nativeSrc": "27519:4:0", + "nodeType": "YulIdentifier", + "src": "27519:4:0" + }, + { + "name": "r", + "nativeSrc": "27525:1:0", + "nodeType": "YulIdentifier", + "src": "27525:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "27506:6:0", + "nodeType": "YulIdentifier", + "src": "27506:6:0" + }, + "nativeSrc": "27506:21:0", + "nodeType": "YulFunctionCall", + "src": "27506:21:0" + }, + "variables": [ + { + "name": "var6", + "nativeSrc": "27498:4:0", + "nodeType": "YulTypedName", + "src": "27498:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27548:31:0", + "nodeType": "YulVariableDeclaration", + "src": "27548:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "27572:6:0", + "nodeType": "YulLiteral", + "src": "27572:6:0", + "type": "", + "value": "0x04a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "27559:12:0", + "nodeType": "YulIdentifier", + "src": "27559:12:0" + }, + "nativeSrc": "27559:20:0", + "nodeType": "YulFunctionCall", + "src": "27559:20:0" + }, + "variables": [ + { + "name": "a_2", + "nativeSrc": "27552:3:0", + "nodeType": "YulTypedName", + "src": "27552:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27600:31:0", + "nodeType": "YulVariableDeclaration", + "src": "27600:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "27624:6:0", + "nodeType": "YulLiteral", + "src": "27624:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "27611:12:0", + "nodeType": "YulIdentifier", + "src": "27611:12:0" + }, + "nativeSrc": "27611:20:0", + "nodeType": "YulFunctionCall", + "src": "27611:20:0" + }, + "variables": [ + { + "name": "a_1", + "nativeSrc": "27604:3:0", + "nodeType": "YulTypedName", + "src": "27604:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27652:38:0", + "nodeType": "YulVariableDeclaration", + "src": "27652:38:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "27683:6:0", + "nodeType": "YulLiteral", + "src": "27683:6:0", + "type": "", + "value": "0x04c4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "27670:12:0", + "nodeType": "YulIdentifier", + "src": "27670:12:0" + }, + "nativeSrc": "27670:20:0", + "nodeType": "YulFunctionCall", + "src": "27670:20:0" + }, + "variables": [ + { + "name": "a_2_prev_1", + "nativeSrc": "27656:10:0", + "nodeType": "YulTypedName", + "src": "27656:10:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27711:38:0", + "nodeType": "YulVariableDeclaration", + "src": "27711:38:0", + "value": { + "arguments": [ + { + "name": "a_1", + "nativeSrc": "27730:3:0", + "nodeType": "YulIdentifier", + "src": "27730:3:0" + }, + { + "name": "a_2_prev_1", + "nativeSrc": "27735:10:0", + "nodeType": "YulIdentifier", + "src": "27735:10:0" + }, + { + "name": "r", + "nativeSrc": "27747:1:0", + "nodeType": "YulIdentifier", + "src": "27747:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "27723:6:0", + "nodeType": "YulIdentifier", + "src": "27723:6:0" + }, + "nativeSrc": "27723:26:0", + "nodeType": "YulFunctionCall", + "src": "27723:26:0" + }, + "variables": [ + { + "name": "var7", + "nativeSrc": "27715:4:0", + "nodeType": "YulTypedName", + "src": "27715:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27770:24:0", + "nodeType": "YulVariableDeclaration", + "src": "27770:24:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "27786:1:0", + "nodeType": "YulIdentifier", + "src": "27786:1:0" + }, + { + "name": "var7", + "nativeSrc": "27789:4:0", + "nodeType": "YulIdentifier", + "src": "27789:4:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "27782:3:0", + "nodeType": "YulIdentifier", + "src": "27782:3:0" + }, + "nativeSrc": "27782:12:0", + "nodeType": "YulFunctionCall", + "src": "27782:12:0" + }, + "variables": [ + { + "name": "var8", + "nativeSrc": "27774:4:0", + "nodeType": "YulTypedName", + "src": "27774:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27815:32:0", + "nodeType": "YulVariableDeclaration", + "src": "27815:32:0", + "value": { + "arguments": [ + { + "name": "a_2", + "nativeSrc": "27834:3:0", + "nodeType": "YulIdentifier", + "src": "27834:3:0" + }, + { + "name": "var8", + "nativeSrc": "27839:4:0", + "nodeType": "YulIdentifier", + "src": "27839:4:0" + }, + { + "name": "r", + "nativeSrc": "27845:1:0", + "nodeType": "YulIdentifier", + "src": "27845:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "27827:6:0", + "nodeType": "YulIdentifier", + "src": "27827:6:0" + }, + "nativeSrc": "27827:20:0", + "nodeType": "YulFunctionCall", + "src": "27827:20:0" + }, + "variables": [ + { + "name": "var9", + "nativeSrc": "27819:4:0", + "nodeType": "YulTypedName", + "src": "27819:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27868:34:0", + "nodeType": "YulVariableDeclaration", + "src": "27868:34:0", + "value": { + "arguments": [ + { + "name": "var6", + "nativeSrc": "27888:4:0", + "nodeType": "YulIdentifier", + "src": "27888:4:0" + }, + { + "name": "var9", + "nativeSrc": "27894:4:0", + "nodeType": "YulIdentifier", + "src": "27894:4:0" + }, + { + "name": "r", + "nativeSrc": "27900:1:0", + "nodeType": "YulIdentifier", + "src": "27900:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "27881:6:0", + "nodeType": "YulIdentifier", + "src": "27881:6:0" + }, + "nativeSrc": "27881:21:0", + "nodeType": "YulFunctionCall", + "src": "27881:21:0" + }, + "variables": [ + { + "name": "var10", + "nativeSrc": "27872:5:0", + "nodeType": "YulTypedName", + "src": "27872:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "27923:74:0", + "nodeType": "YulAssignment", + "src": "27923:74:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "27960:19:0", + "nodeType": "YulIdentifier", + "src": "27960:19:0" + }, + { + "name": "y", + "nativeSrc": "27981:1:0", + "nodeType": "YulIdentifier", + "src": "27981:1:0" + }, + { + "name": "r", + "nativeSrc": "27984:1:0", + "nodeType": "YulIdentifier", + "src": "27984:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "27953:6:0", + "nodeType": "YulIdentifier", + "src": "27953:6:0" + }, + "nativeSrc": "27953:33:0", + "nodeType": "YulFunctionCall", + "src": "27953:33:0" + }, + { + "name": "var10", + "nativeSrc": "27988:5:0", + "nodeType": "YulIdentifier", + "src": "27988:5:0" + }, + { + "name": "r", + "nativeSrc": "27995:1:0", + "nodeType": "YulIdentifier", + "src": "27995:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "27946:6:0", + "nodeType": "YulIdentifier", + "src": "27946:6:0" + }, + "nativeSrc": "27946:51:0", + "nodeType": "YulFunctionCall", + "src": "27946:51:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "27923:19:0", + "nodeType": "YulIdentifier", + "src": "27923:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "28032:754:0", + "nodeType": "YulBlock", + "src": "28032:754:0", + "statements": [ + { + "nativeSrc": "28054:32:0", + "nodeType": "YulVariableDeclaration", + "src": "28054:32:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "28079:6:0", + "nodeType": "YulLiteral", + "src": "28079:6:0", + "type": "", + "value": "0x0624" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "28066:12:0", + "nodeType": "YulIdentifier", + "src": "28066:12:0" + }, + "nativeSrc": "28066:20:0", + "nodeType": "YulFunctionCall", + "src": "28066:20:0" + }, + "variables": [ + { + "name": "f_10", + "nativeSrc": "28058:4:0", + "nodeType": "YulTypedName", + "src": "28058:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28107:15:0", + "nodeType": "YulVariableDeclaration", + "src": "28107:15:0", + "value": { + "kind": "number", + "nativeSrc": "28119:3:0", + "nodeType": "YulLiteral", + "src": "28119:3:0", + "type": "", + "value": "0x1" + }, + "variables": [ + { + "name": "var0", + "nativeSrc": "28111:4:0", + "nodeType": "YulTypedName", + "src": "28111:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28143:24:0", + "nodeType": "YulVariableDeclaration", + "src": "28143:24:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "28159:1:0", + "nodeType": "YulIdentifier", + "src": "28159:1:0" + }, + { + "name": "f_10", + "nativeSrc": "28162:4:0", + "nodeType": "YulIdentifier", + "src": "28162:4:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "28155:3:0", + "nodeType": "YulIdentifier", + "src": "28155:3:0" + }, + "nativeSrc": "28155:12:0", + "nodeType": "YulFunctionCall", + "src": "28155:12:0" + }, + "variables": [ + { + "name": "var1", + "nativeSrc": "28147:4:0", + "nodeType": "YulTypedName", + "src": "28147:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28188:33:0", + "nodeType": "YulVariableDeclaration", + "src": "28188:33:0", + "value": { + "arguments": [ + { + "name": "var0", + "nativeSrc": "28207:4:0", + "nodeType": "YulIdentifier", + "src": "28207:4:0" + }, + { + "name": "var1", + "nativeSrc": "28213:4:0", + "nodeType": "YulIdentifier", + "src": "28213:4:0" + }, + { + "name": "r", + "nativeSrc": "28219:1:0", + "nodeType": "YulIdentifier", + "src": "28219:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "28200:6:0", + "nodeType": "YulIdentifier", + "src": "28200:6:0" + }, + "nativeSrc": "28200:21:0", + "nodeType": "YulFunctionCall", + "src": "28200:21:0" + }, + "variables": [ + { + "name": "var2", + "nativeSrc": "28192:4:0", + "nodeType": "YulTypedName", + "src": "28192:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28242:33:0", + "nodeType": "YulVariableDeclaration", + "src": "28242:33:0", + "value": { + "arguments": [ + { + "name": "f_10", + "nativeSrc": "28261:4:0", + "nodeType": "YulIdentifier", + "src": "28261:4:0" + }, + { + "name": "var2", + "nativeSrc": "28267:4:0", + "nodeType": "YulIdentifier", + "src": "28267:4:0" + }, + { + "name": "r", + "nativeSrc": "28273:1:0", + "nodeType": "YulIdentifier", + "src": "28273:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "28254:6:0", + "nodeType": "YulIdentifier", + "src": "28254:6:0" + }, + "nativeSrc": "28254:21:0", + "nodeType": "YulFunctionCall", + "src": "28254:21:0" + }, + "variables": [ + { + "name": "var3", + "nativeSrc": "28246:4:0", + "nodeType": "YulTypedName", + "src": "28246:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28296:15:0", + "nodeType": "YulVariableDeclaration", + "src": "28296:15:0", + "value": { + "kind": "number", + "nativeSrc": "28308:3:0", + "nodeType": "YulLiteral", + "src": "28308:3:0", + "type": "", + "value": "0x2" + }, + "variables": [ + { + "name": "var4", + "nativeSrc": "28300:4:0", + "nodeType": "YulTypedName", + "src": "28300:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28332:33:0", + "nodeType": "YulVariableDeclaration", + "src": "28332:33:0", + "value": { + "arguments": [ + { + "name": "var4", + "nativeSrc": "28351:4:0", + "nodeType": "YulIdentifier", + "src": "28351:4:0" + }, + { + "name": "var1", + "nativeSrc": "28357:4:0", + "nodeType": "YulIdentifier", + "src": "28357:4:0" + }, + { + "name": "r", + "nativeSrc": "28363:1:0", + "nodeType": "YulIdentifier", + "src": "28363:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "28344:6:0", + "nodeType": "YulIdentifier", + "src": "28344:6:0" + }, + "nativeSrc": "28344:21:0", + "nodeType": "YulFunctionCall", + "src": "28344:21:0" + }, + "variables": [ + { + "name": "var5", + "nativeSrc": "28336:4:0", + "nodeType": "YulTypedName", + "src": "28336:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28386:33:0", + "nodeType": "YulVariableDeclaration", + "src": "28386:33:0", + "value": { + "arguments": [ + { + "name": "var3", + "nativeSrc": "28405:4:0", + "nodeType": "YulIdentifier", + "src": "28405:4:0" + }, + { + "name": "var5", + "nativeSrc": "28411:4:0", + "nodeType": "YulIdentifier", + "src": "28411:4:0" + }, + { + "name": "r", + "nativeSrc": "28417:1:0", + "nodeType": "YulIdentifier", + "src": "28417:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "28398:6:0", + "nodeType": "YulIdentifier", + "src": "28398:6:0" + }, + "nativeSrc": "28398:21:0", + "nodeType": "YulFunctionCall", + "src": "28398:21:0" + }, + "variables": [ + { + "name": "var6", + "nativeSrc": "28390:4:0", + "nodeType": "YulTypedName", + "src": "28390:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28440:31:0", + "nodeType": "YulVariableDeclaration", + "src": "28440:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "28464:6:0", + "nodeType": "YulLiteral", + "src": "28464:6:0", + "type": "", + "value": "0x04a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "28451:12:0", + "nodeType": "YulIdentifier", + "src": "28451:12:0" + }, + "nativeSrc": "28451:20:0", + "nodeType": "YulFunctionCall", + "src": "28451:20:0" + }, + "variables": [ + { + "name": "a_2", + "nativeSrc": "28444:3:0", + "nodeType": "YulTypedName", + "src": "28444:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28492:31:0", + "nodeType": "YulVariableDeclaration", + "src": "28492:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "28516:6:0", + "nodeType": "YulLiteral", + "src": "28516:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "28503:12:0", + "nodeType": "YulIdentifier", + "src": "28503:12:0" + }, + "nativeSrc": "28503:20:0", + "nodeType": "YulFunctionCall", + "src": "28503:20:0" + }, + "variables": [ + { + "name": "a_1", + "nativeSrc": "28496:3:0", + "nodeType": "YulTypedName", + "src": "28496:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28544:23:0", + "nodeType": "YulVariableDeclaration", + "src": "28544:23:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "28560:1:0", + "nodeType": "YulIdentifier", + "src": "28560:1:0" + }, + { + "name": "a_1", + "nativeSrc": "28563:3:0", + "nodeType": "YulIdentifier", + "src": "28563:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "28556:3:0", + "nodeType": "YulIdentifier", + "src": "28556:3:0" + }, + "nativeSrc": "28556:11:0", + "nodeType": "YulFunctionCall", + "src": "28556:11:0" + }, + "variables": [ + { + "name": "var7", + "nativeSrc": "28548:4:0", + "nodeType": "YulTypedName", + "src": "28548:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28588:32:0", + "nodeType": "YulVariableDeclaration", + "src": "28588:32:0", + "value": { + "arguments": [ + { + "name": "a_2", + "nativeSrc": "28607:3:0", + "nodeType": "YulIdentifier", + "src": "28607:3:0" + }, + { + "name": "var7", + "nativeSrc": "28612:4:0", + "nodeType": "YulIdentifier", + "src": "28612:4:0" + }, + { + "name": "r", + "nativeSrc": "28618:1:0", + "nodeType": "YulIdentifier", + "src": "28618:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "28600:6:0", + "nodeType": "YulIdentifier", + "src": "28600:6:0" + }, + "nativeSrc": "28600:20:0", + "nodeType": "YulFunctionCall", + "src": "28600:20:0" + }, + "variables": [ + { + "name": "var8", + "nativeSrc": "28592:4:0", + "nodeType": "YulTypedName", + "src": "28592:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28641:33:0", + "nodeType": "YulVariableDeclaration", + "src": "28641:33:0", + "value": { + "arguments": [ + { + "name": "var6", + "nativeSrc": "28660:4:0", + "nodeType": "YulIdentifier", + "src": "28660:4:0" + }, + { + "name": "var8", + "nativeSrc": "28666:4:0", + "nodeType": "YulIdentifier", + "src": "28666:4:0" + }, + { + "name": "r", + "nativeSrc": "28672:1:0", + "nodeType": "YulIdentifier", + "src": "28672:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "28653:6:0", + "nodeType": "YulIdentifier", + "src": "28653:6:0" + }, + "nativeSrc": "28653:21:0", + "nodeType": "YulFunctionCall", + "src": "28653:21:0" + }, + "variables": [ + { + "name": "var9", + "nativeSrc": "28645:4:0", + "nodeType": "YulTypedName", + "src": "28645:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28695:73:0", + "nodeType": "YulAssignment", + "src": "28695:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "28732:19:0", + "nodeType": "YulIdentifier", + "src": "28732:19:0" + }, + { + "name": "y", + "nativeSrc": "28753:1:0", + "nodeType": "YulIdentifier", + "src": "28753:1:0" + }, + { + "name": "r", + "nativeSrc": "28756:1:0", + "nodeType": "YulIdentifier", + "src": "28756:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "28725:6:0", + "nodeType": "YulIdentifier", + "src": "28725:6:0" + }, + "nativeSrc": "28725:33:0", + "nodeType": "YulFunctionCall", + "src": "28725:33:0" + }, + { + "name": "var9", + "nativeSrc": "28760:4:0", + "nodeType": "YulIdentifier", + "src": "28760:4:0" + }, + { + "name": "r", + "nativeSrc": "28766:1:0", + "nodeType": "YulIdentifier", + "src": "28766:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "28718:6:0", + "nodeType": "YulIdentifier", + "src": "28718:6:0" + }, + "nativeSrc": "28718:50:0", + "nodeType": "YulFunctionCall", + "src": "28718:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "28695:19:0", + "nodeType": "YulIdentifier", + "src": "28695:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "28803:858:0", + "nodeType": "YulBlock", + "src": "28803:858:0", + "statements": [ + { + "nativeSrc": "28825:31:0", + "nodeType": "YulVariableDeclaration", + "src": "28825:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "28849:6:0", + "nodeType": "YulLiteral", + "src": "28849:6:0", + "type": "", + "value": "0x05e4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "28836:12:0", + "nodeType": "YulIdentifier", + "src": "28836:12:0" + }, + "nativeSrc": "28836:20:0", + "nodeType": "YulFunctionCall", + "src": "28836:20:0" + }, + "variables": [ + { + "name": "f_8", + "nativeSrc": "28829:3:0", + "nodeType": "YulTypedName", + "src": "28829:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28877:15:0", + "nodeType": "YulVariableDeclaration", + "src": "28877:15:0", + "value": { + "kind": "number", + "nativeSrc": "28889:3:0", + "nodeType": "YulLiteral", + "src": "28889:3:0", + "type": "", + "value": "0x2" + }, + "variables": [ + { + "name": "var0", + "nativeSrc": "28881:4:0", + "nodeType": "YulTypedName", + "src": "28881:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28913:23:0", + "nodeType": "YulVariableDeclaration", + "src": "28913:23:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "28929:1:0", + "nodeType": "YulIdentifier", + "src": "28929:1:0" + }, + { + "name": "f_8", + "nativeSrc": "28932:3:0", + "nodeType": "YulIdentifier", + "src": "28932:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "28925:3:0", + "nodeType": "YulIdentifier", + "src": "28925:3:0" + }, + "nativeSrc": "28925:11:0", + "nodeType": "YulFunctionCall", + "src": "28925:11:0" + }, + "variables": [ + { + "name": "var1", + "nativeSrc": "28917:4:0", + "nodeType": "YulTypedName", + "src": "28917:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "28957:33:0", + "nodeType": "YulVariableDeclaration", + "src": "28957:33:0", + "value": { + "arguments": [ + { + "name": "var0", + "nativeSrc": "28976:4:0", + "nodeType": "YulIdentifier", + "src": "28976:4:0" + }, + { + "name": "var1", + "nativeSrc": "28982:4:0", + "nodeType": "YulIdentifier", + "src": "28982:4:0" + }, + { + "name": "r", + "nativeSrc": "28988:1:0", + "nodeType": "YulIdentifier", + "src": "28988:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "28969:6:0", + "nodeType": "YulIdentifier", + "src": "28969:6:0" + }, + "nativeSrc": "28969:21:0", + "nodeType": "YulFunctionCall", + "src": "28969:21:0" + }, + "variables": [ + { + "name": "var2", + "nativeSrc": "28961:4:0", + "nodeType": "YulTypedName", + "src": "28961:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29011:32:0", + "nodeType": "YulVariableDeclaration", + "src": "29011:32:0", + "value": { + "arguments": [ + { + "name": "f_8", + "nativeSrc": "29030:3:0", + "nodeType": "YulIdentifier", + "src": "29030:3:0" + }, + { + "name": "var2", + "nativeSrc": "29035:4:0", + "nodeType": "YulIdentifier", + "src": "29035:4:0" + }, + { + "name": "r", + "nativeSrc": "29041:1:0", + "nodeType": "YulIdentifier", + "src": "29041:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "29023:6:0", + "nodeType": "YulIdentifier", + "src": "29023:6:0" + }, + "nativeSrc": "29023:20:0", + "nodeType": "YulFunctionCall", + "src": "29023:20:0" + }, + "variables": [ + { + "name": "var3", + "nativeSrc": "29015:4:0", + "nodeType": "YulTypedName", + "src": "29015:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29064:15:0", + "nodeType": "YulVariableDeclaration", + "src": "29064:15:0", + "value": { + "kind": "number", + "nativeSrc": "29076:3:0", + "nodeType": "YulLiteral", + "src": "29076:3:0", + "type": "", + "value": "0x3" + }, + "variables": [ + { + "name": "var4", + "nativeSrc": "29068:4:0", + "nodeType": "YulTypedName", + "src": "29068:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29100:33:0", + "nodeType": "YulVariableDeclaration", + "src": "29100:33:0", + "value": { + "arguments": [ + { + "name": "var4", + "nativeSrc": "29119:4:0", + "nodeType": "YulIdentifier", + "src": "29119:4:0" + }, + { + "name": "var1", + "nativeSrc": "29125:4:0", + "nodeType": "YulIdentifier", + "src": "29125:4:0" + }, + { + "name": "r", + "nativeSrc": "29131:1:0", + "nodeType": "YulIdentifier", + "src": "29131:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "29112:6:0", + "nodeType": "YulIdentifier", + "src": "29112:6:0" + }, + "nativeSrc": "29112:21:0", + "nodeType": "YulFunctionCall", + "src": "29112:21:0" + }, + "variables": [ + { + "name": "var5", + "nativeSrc": "29104:4:0", + "nodeType": "YulTypedName", + "src": "29104:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29154:33:0", + "nodeType": "YulVariableDeclaration", + "src": "29154:33:0", + "value": { + "arguments": [ + { + "name": "var3", + "nativeSrc": "29173:4:0", + "nodeType": "YulIdentifier", + "src": "29173:4:0" + }, + { + "name": "var5", + "nativeSrc": "29179:4:0", + "nodeType": "YulIdentifier", + "src": "29179:4:0" + }, + { + "name": "r", + "nativeSrc": "29185:1:0", + "nodeType": "YulIdentifier", + "src": "29185:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "29166:6:0", + "nodeType": "YulIdentifier", + "src": "29166:6:0" + }, + "nativeSrc": "29166:21:0", + "nodeType": "YulFunctionCall", + "src": "29166:21:0" + }, + "variables": [ + { + "name": "var6", + "nativeSrc": "29158:4:0", + "nodeType": "YulTypedName", + "src": "29158:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29208:31:0", + "nodeType": "YulVariableDeclaration", + "src": "29208:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "29232:6:0", + "nodeType": "YulLiteral", + "src": "29232:6:0", + "type": "", + "value": "0x04a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "29219:12:0", + "nodeType": "YulIdentifier", + "src": "29219:12:0" + }, + "nativeSrc": "29219:20:0", + "nodeType": "YulFunctionCall", + "src": "29219:20:0" + }, + "variables": [ + { + "name": "a_2", + "nativeSrc": "29212:3:0", + "nodeType": "YulTypedName", + "src": "29212:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29260:31:0", + "nodeType": "YulVariableDeclaration", + "src": "29260:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "29284:6:0", + "nodeType": "YulLiteral", + "src": "29284:6:0", + "type": "", + "value": "0x0464" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "29271:12:0", + "nodeType": "YulIdentifier", + "src": "29271:12:0" + }, + "nativeSrc": "29271:20:0", + "nodeType": "YulFunctionCall", + "src": "29271:20:0" + }, + "variables": [ + { + "name": "a_0", + "nativeSrc": "29264:3:0", + "nodeType": "YulTypedName", + "src": "29264:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29312:31:0", + "nodeType": "YulVariableDeclaration", + "src": "29312:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "29336:6:0", + "nodeType": "YulLiteral", + "src": "29336:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "29323:12:0", + "nodeType": "YulIdentifier", + "src": "29323:12:0" + }, + "nativeSrc": "29323:20:0", + "nodeType": "YulFunctionCall", + "src": "29323:20:0" + }, + "variables": [ + { + "name": "a_1", + "nativeSrc": "29316:3:0", + "nodeType": "YulTypedName", + "src": "29316:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29364:31:0", + "nodeType": "YulVariableDeclaration", + "src": "29364:31:0", + "value": { + "arguments": [ + { + "name": "a_0", + "nativeSrc": "29383:3:0", + "nodeType": "YulIdentifier", + "src": "29383:3:0" + }, + { + "name": "a_1", + "nativeSrc": "29388:3:0", + "nodeType": "YulIdentifier", + "src": "29388:3:0" + }, + { + "name": "r", + "nativeSrc": "29393:1:0", + "nodeType": "YulIdentifier", + "src": "29393:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "29376:6:0", + "nodeType": "YulIdentifier", + "src": "29376:6:0" + }, + "nativeSrc": "29376:19:0", + "nodeType": "YulFunctionCall", + "src": "29376:19:0" + }, + "variables": [ + { + "name": "var7", + "nativeSrc": "29368:4:0", + "nodeType": "YulTypedName", + "src": "29368:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29416:24:0", + "nodeType": "YulVariableDeclaration", + "src": "29416:24:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "29432:1:0", + "nodeType": "YulIdentifier", + "src": "29432:1:0" + }, + { + "name": "var7", + "nativeSrc": "29435:4:0", + "nodeType": "YulIdentifier", + "src": "29435:4:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "29428:3:0", + "nodeType": "YulIdentifier", + "src": "29428:3:0" + }, + "nativeSrc": "29428:12:0", + "nodeType": "YulFunctionCall", + "src": "29428:12:0" + }, + "variables": [ + { + "name": "var8", + "nativeSrc": "29420:4:0", + "nodeType": "YulTypedName", + "src": "29420:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29461:32:0", + "nodeType": "YulVariableDeclaration", + "src": "29461:32:0", + "value": { + "arguments": [ + { + "name": "a_2", + "nativeSrc": "29480:3:0", + "nodeType": "YulIdentifier", + "src": "29480:3:0" + }, + { + "name": "var8", + "nativeSrc": "29485:4:0", + "nodeType": "YulIdentifier", + "src": "29485:4:0" + }, + { + "name": "r", + "nativeSrc": "29491:1:0", + "nodeType": "YulIdentifier", + "src": "29491:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "29473:6:0", + "nodeType": "YulIdentifier", + "src": "29473:6:0" + }, + "nativeSrc": "29473:20:0", + "nodeType": "YulFunctionCall", + "src": "29473:20:0" + }, + "variables": [ + { + "name": "var9", + "nativeSrc": "29465:4:0", + "nodeType": "YulTypedName", + "src": "29465:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29514:34:0", + "nodeType": "YulVariableDeclaration", + "src": "29514:34:0", + "value": { + "arguments": [ + { + "name": "var6", + "nativeSrc": "29534:4:0", + "nodeType": "YulIdentifier", + "src": "29534:4:0" + }, + { + "name": "var9", + "nativeSrc": "29540:4:0", + "nodeType": "YulIdentifier", + "src": "29540:4:0" + }, + { + "name": "r", + "nativeSrc": "29546:1:0", + "nodeType": "YulIdentifier", + "src": "29546:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "29527:6:0", + "nodeType": "YulIdentifier", + "src": "29527:6:0" + }, + "nativeSrc": "29527:21:0", + "nodeType": "YulFunctionCall", + "src": "29527:21:0" + }, + "variables": [ + { + "name": "var10", + "nativeSrc": "29518:5:0", + "nodeType": "YulTypedName", + "src": "29518:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29569:74:0", + "nodeType": "YulAssignment", + "src": "29569:74:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "29606:19:0", + "nodeType": "YulIdentifier", + "src": "29606:19:0" + }, + { + "name": "y", + "nativeSrc": "29627:1:0", + "nodeType": "YulIdentifier", + "src": "29627:1:0" + }, + { + "name": "r", + "nativeSrc": "29630:1:0", + "nodeType": "YulIdentifier", + "src": "29630:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "29599:6:0", + "nodeType": "YulIdentifier", + "src": "29599:6:0" + }, + "nativeSrc": "29599:33:0", + "nodeType": "YulFunctionCall", + "src": "29599:33:0" + }, + { + "name": "var10", + "nativeSrc": "29634:5:0", + "nodeType": "YulIdentifier", + "src": "29634:5:0" + }, + { + "name": "r", + "nativeSrc": "29641:1:0", + "nodeType": "YulIdentifier", + "src": "29641:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "29592:6:0", + "nodeType": "YulIdentifier", + "src": "29592:6:0" + }, + "nativeSrc": "29592:51:0", + "nodeType": "YulFunctionCall", + "src": "29592:51:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "29569:19:0", + "nodeType": "YulIdentifier", + "src": "29569:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "29678:861:0", + "nodeType": "YulBlock", + "src": "29678:861:0", + "statements": [ + { + "nativeSrc": "29700:32:0", + "nodeType": "YulVariableDeclaration", + "src": "29700:32:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "29725:6:0", + "nodeType": "YulLiteral", + "src": "29725:6:0", + "type": "", + "value": "0x0624" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "29712:12:0", + "nodeType": "YulIdentifier", + "src": "29712:12:0" + }, + "nativeSrc": "29712:20:0", + "nodeType": "YulFunctionCall", + "src": "29712:20:0" + }, + "variables": [ + { + "name": "f_10", + "nativeSrc": "29704:4:0", + "nodeType": "YulTypedName", + "src": "29704:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29753:15:0", + "nodeType": "YulVariableDeclaration", + "src": "29753:15:0", + "value": { + "kind": "number", + "nativeSrc": "29765:3:0", + "nodeType": "YulLiteral", + "src": "29765:3:0", + "type": "", + "value": "0x2" + }, + "variables": [ + { + "name": "var0", + "nativeSrc": "29757:4:0", + "nodeType": "YulTypedName", + "src": "29757:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29789:24:0", + "nodeType": "YulVariableDeclaration", + "src": "29789:24:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "29805:1:0", + "nodeType": "YulIdentifier", + "src": "29805:1:0" + }, + { + "name": "f_10", + "nativeSrc": "29808:4:0", + "nodeType": "YulIdentifier", + "src": "29808:4:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "29801:3:0", + "nodeType": "YulIdentifier", + "src": "29801:3:0" + }, + "nativeSrc": "29801:12:0", + "nodeType": "YulFunctionCall", + "src": "29801:12:0" + }, + "variables": [ + { + "name": "var1", + "nativeSrc": "29793:4:0", + "nodeType": "YulTypedName", + "src": "29793:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29834:33:0", + "nodeType": "YulVariableDeclaration", + "src": "29834:33:0", + "value": { + "arguments": [ + { + "name": "var0", + "nativeSrc": "29853:4:0", + "nodeType": "YulIdentifier", + "src": "29853:4:0" + }, + { + "name": "var1", + "nativeSrc": "29859:4:0", + "nodeType": "YulIdentifier", + "src": "29859:4:0" + }, + { + "name": "r", + "nativeSrc": "29865:1:0", + "nodeType": "YulIdentifier", + "src": "29865:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "29846:6:0", + "nodeType": "YulIdentifier", + "src": "29846:6:0" + }, + "nativeSrc": "29846:21:0", + "nodeType": "YulFunctionCall", + "src": "29846:21:0" + }, + "variables": [ + { + "name": "var2", + "nativeSrc": "29838:4:0", + "nodeType": "YulTypedName", + "src": "29838:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29888:33:0", + "nodeType": "YulVariableDeclaration", + "src": "29888:33:0", + "value": { + "arguments": [ + { + "name": "f_10", + "nativeSrc": "29907:4:0", + "nodeType": "YulIdentifier", + "src": "29907:4:0" + }, + { + "name": "var2", + "nativeSrc": "29913:4:0", + "nodeType": "YulIdentifier", + "src": "29913:4:0" + }, + { + "name": "r", + "nativeSrc": "29919:1:0", + "nodeType": "YulIdentifier", + "src": "29919:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "29900:6:0", + "nodeType": "YulIdentifier", + "src": "29900:6:0" + }, + "nativeSrc": "29900:21:0", + "nodeType": "YulFunctionCall", + "src": "29900:21:0" + }, + "variables": [ + { + "name": "var3", + "nativeSrc": "29892:4:0", + "nodeType": "YulTypedName", + "src": "29892:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29942:15:0", + "nodeType": "YulVariableDeclaration", + "src": "29942:15:0", + "value": { + "kind": "number", + "nativeSrc": "29954:3:0", + "nodeType": "YulLiteral", + "src": "29954:3:0", + "type": "", + "value": "0x3" + }, + "variables": [ + { + "name": "var4", + "nativeSrc": "29946:4:0", + "nodeType": "YulTypedName", + "src": "29946:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "29978:33:0", + "nodeType": "YulVariableDeclaration", + "src": "29978:33:0", + "value": { + "arguments": [ + { + "name": "var4", + "nativeSrc": "29997:4:0", + "nodeType": "YulIdentifier", + "src": "29997:4:0" + }, + { + "name": "var1", + "nativeSrc": "30003:4:0", + "nodeType": "YulIdentifier", + "src": "30003:4:0" + }, + { + "name": "r", + "nativeSrc": "30009:1:0", + "nodeType": "YulIdentifier", + "src": "30009:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "29990:6:0", + "nodeType": "YulIdentifier", + "src": "29990:6:0" + }, + "nativeSrc": "29990:21:0", + "nodeType": "YulFunctionCall", + "src": "29990:21:0" + }, + "variables": [ + { + "name": "var5", + "nativeSrc": "29982:4:0", + "nodeType": "YulTypedName", + "src": "29982:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30032:33:0", + "nodeType": "YulVariableDeclaration", + "src": "30032:33:0", + "value": { + "arguments": [ + { + "name": "var3", + "nativeSrc": "30051:4:0", + "nodeType": "YulIdentifier", + "src": "30051:4:0" + }, + { + "name": "var5", + "nativeSrc": "30057:4:0", + "nodeType": "YulIdentifier", + "src": "30057:4:0" + }, + { + "name": "r", + "nativeSrc": "30063:1:0", + "nodeType": "YulIdentifier", + "src": "30063:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "30044:6:0", + "nodeType": "YulIdentifier", + "src": "30044:6:0" + }, + "nativeSrc": "30044:21:0", + "nodeType": "YulFunctionCall", + "src": "30044:21:0" + }, + "variables": [ + { + "name": "var6", + "nativeSrc": "30036:4:0", + "nodeType": "YulTypedName", + "src": "30036:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30086:31:0", + "nodeType": "YulVariableDeclaration", + "src": "30086:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "30110:6:0", + "nodeType": "YulLiteral", + "src": "30110:6:0", + "type": "", + "value": "0x04a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "30097:12:0", + "nodeType": "YulIdentifier", + "src": "30097:12:0" + }, + "nativeSrc": "30097:20:0", + "nodeType": "YulFunctionCall", + "src": "30097:20:0" + }, + "variables": [ + { + "name": "a_2", + "nativeSrc": "30090:3:0", + "nodeType": "YulTypedName", + "src": "30090:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30138:31:0", + "nodeType": "YulVariableDeclaration", + "src": "30138:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "30162:6:0", + "nodeType": "YulLiteral", + "src": "30162:6:0", + "type": "", + "value": "0x0464" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "30149:12:0", + "nodeType": "YulIdentifier", + "src": "30149:12:0" + }, + "nativeSrc": "30149:20:0", + "nodeType": "YulFunctionCall", + "src": "30149:20:0" + }, + "variables": [ + { + "name": "a_0", + "nativeSrc": "30142:3:0", + "nodeType": "YulTypedName", + "src": "30142:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30190:31:0", + "nodeType": "YulVariableDeclaration", + "src": "30190:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "30214:6:0", + "nodeType": "YulLiteral", + "src": "30214:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "30201:12:0", + "nodeType": "YulIdentifier", + "src": "30201:12:0" + }, + "nativeSrc": "30201:20:0", + "nodeType": "YulFunctionCall", + "src": "30201:20:0" + }, + "variables": [ + { + "name": "a_1", + "nativeSrc": "30194:3:0", + "nodeType": "YulTypedName", + "src": "30194:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30242:31:0", + "nodeType": "YulVariableDeclaration", + "src": "30242:31:0", + "value": { + "arguments": [ + { + "name": "a_0", + "nativeSrc": "30261:3:0", + "nodeType": "YulIdentifier", + "src": "30261:3:0" + }, + { + "name": "a_1", + "nativeSrc": "30266:3:0", + "nodeType": "YulIdentifier", + "src": "30266:3:0" + }, + { + "name": "r", + "nativeSrc": "30271:1:0", + "nodeType": "YulIdentifier", + "src": "30271:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "30254:6:0", + "nodeType": "YulIdentifier", + "src": "30254:6:0" + }, + "nativeSrc": "30254:19:0", + "nodeType": "YulFunctionCall", + "src": "30254:19:0" + }, + "variables": [ + { + "name": "var7", + "nativeSrc": "30246:4:0", + "nodeType": "YulTypedName", + "src": "30246:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30294:24:0", + "nodeType": "YulVariableDeclaration", + "src": "30294:24:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "30310:1:0", + "nodeType": "YulIdentifier", + "src": "30310:1:0" + }, + { + "name": "var7", + "nativeSrc": "30313:4:0", + "nodeType": "YulIdentifier", + "src": "30313:4:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "30306:3:0", + "nodeType": "YulIdentifier", + "src": "30306:3:0" + }, + "nativeSrc": "30306:12:0", + "nodeType": "YulFunctionCall", + "src": "30306:12:0" + }, + "variables": [ + { + "name": "var8", + "nativeSrc": "30298:4:0", + "nodeType": "YulTypedName", + "src": "30298:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30339:32:0", + "nodeType": "YulVariableDeclaration", + "src": "30339:32:0", + "value": { + "arguments": [ + { + "name": "a_2", + "nativeSrc": "30358:3:0", + "nodeType": "YulIdentifier", + "src": "30358:3:0" + }, + { + "name": "var8", + "nativeSrc": "30363:4:0", + "nodeType": "YulIdentifier", + "src": "30363:4:0" + }, + { + "name": "r", + "nativeSrc": "30369:1:0", + "nodeType": "YulIdentifier", + "src": "30369:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "30351:6:0", + "nodeType": "YulIdentifier", + "src": "30351:6:0" + }, + "nativeSrc": "30351:20:0", + "nodeType": "YulFunctionCall", + "src": "30351:20:0" + }, + "variables": [ + { + "name": "var9", + "nativeSrc": "30343:4:0", + "nodeType": "YulTypedName", + "src": "30343:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30392:34:0", + "nodeType": "YulVariableDeclaration", + "src": "30392:34:0", + "value": { + "arguments": [ + { + "name": "var6", + "nativeSrc": "30412:4:0", + "nodeType": "YulIdentifier", + "src": "30412:4:0" + }, + { + "name": "var9", + "nativeSrc": "30418:4:0", + "nodeType": "YulIdentifier", + "src": "30418:4:0" + }, + { + "name": "r", + "nativeSrc": "30424:1:0", + "nodeType": "YulIdentifier", + "src": "30424:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "30405:6:0", + "nodeType": "YulIdentifier", + "src": "30405:6:0" + }, + "nativeSrc": "30405:21:0", + "nodeType": "YulFunctionCall", + "src": "30405:21:0" + }, + "variables": [ + { + "name": "var10", + "nativeSrc": "30396:5:0", + "nodeType": "YulTypedName", + "src": "30396:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30447:74:0", + "nodeType": "YulAssignment", + "src": "30447:74:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "30484:19:0", + "nodeType": "YulIdentifier", + "src": "30484:19:0" + }, + { + "name": "y", + "nativeSrc": "30505:1:0", + "nodeType": "YulIdentifier", + "src": "30505:1:0" + }, + { + "name": "r", + "nativeSrc": "30508:1:0", + "nodeType": "YulIdentifier", + "src": "30508:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "30477:6:0", + "nodeType": "YulIdentifier", + "src": "30477:6:0" + }, + "nativeSrc": "30477:33:0", + "nodeType": "YulFunctionCall", + "src": "30477:33:0" + }, + { + "name": "var10", + "nativeSrc": "30512:5:0", + "nodeType": "YulIdentifier", + "src": "30512:5:0" + }, + { + "name": "r", + "nativeSrc": "30519:1:0", + "nodeType": "YulIdentifier", + "src": "30519:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "30470:6:0", + "nodeType": "YulIdentifier", + "src": "30470:6:0" + }, + "nativeSrc": "30470:51:0", + "nodeType": "YulFunctionCall", + "src": "30470:51:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "30447:19:0", + "nodeType": "YulIdentifier", + "src": "30447:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "30556:905:0", + "nodeType": "YulBlock", + "src": "30556:905:0", + "statements": [ + { + "nativeSrc": "30578:31:0", + "nodeType": "YulVariableDeclaration", + "src": "30578:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "30602:6:0", + "nodeType": "YulLiteral", + "src": "30602:6:0", + "type": "", + "value": "0x05e4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "30589:12:0", + "nodeType": "YulIdentifier", + "src": "30589:12:0" + }, + "nativeSrc": "30589:20:0", + "nodeType": "YulFunctionCall", + "src": "30589:20:0" + }, + "variables": [ + { + "name": "f_8", + "nativeSrc": "30582:3:0", + "nodeType": "YulTypedName", + "src": "30582:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30630:15:0", + "nodeType": "YulVariableDeclaration", + "src": "30630:15:0", + "value": { + "kind": "number", + "nativeSrc": "30642:3:0", + "nodeType": "YulLiteral", + "src": "30642:3:0", + "type": "", + "value": "0x1" + }, + "variables": [ + { + "name": "var0", + "nativeSrc": "30634:4:0", + "nodeType": "YulTypedName", + "src": "30634:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30666:23:0", + "nodeType": "YulVariableDeclaration", + "src": "30666:23:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "30682:1:0", + "nodeType": "YulIdentifier", + "src": "30682:1:0" + }, + { + "name": "f_8", + "nativeSrc": "30685:3:0", + "nodeType": "YulIdentifier", + "src": "30685:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "30678:3:0", + "nodeType": "YulIdentifier", + "src": "30678:3:0" + }, + "nativeSrc": "30678:11:0", + "nodeType": "YulFunctionCall", + "src": "30678:11:0" + }, + "variables": [ + { + "name": "var1", + "nativeSrc": "30670:4:0", + "nodeType": "YulTypedName", + "src": "30670:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30710:33:0", + "nodeType": "YulVariableDeclaration", + "src": "30710:33:0", + "value": { + "arguments": [ + { + "name": "var0", + "nativeSrc": "30729:4:0", + "nodeType": "YulIdentifier", + "src": "30729:4:0" + }, + { + "name": "var1", + "nativeSrc": "30735:4:0", + "nodeType": "YulIdentifier", + "src": "30735:4:0" + }, + { + "name": "r", + "nativeSrc": "30741:1:0", + "nodeType": "YulIdentifier", + "src": "30741:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "30722:6:0", + "nodeType": "YulIdentifier", + "src": "30722:6:0" + }, + "nativeSrc": "30722:21:0", + "nodeType": "YulFunctionCall", + "src": "30722:21:0" + }, + "variables": [ + { + "name": "var2", + "nativeSrc": "30714:4:0", + "nodeType": "YulTypedName", + "src": "30714:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30764:32:0", + "nodeType": "YulVariableDeclaration", + "src": "30764:32:0", + "value": { + "arguments": [ + { + "name": "f_8", + "nativeSrc": "30783:3:0", + "nodeType": "YulIdentifier", + "src": "30783:3:0" + }, + { + "name": "var2", + "nativeSrc": "30788:4:0", + "nodeType": "YulIdentifier", + "src": "30788:4:0" + }, + { + "name": "r", + "nativeSrc": "30794:1:0", + "nodeType": "YulIdentifier", + "src": "30794:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "30776:6:0", + "nodeType": "YulIdentifier", + "src": "30776:6:0" + }, + "nativeSrc": "30776:20:0", + "nodeType": "YulFunctionCall", + "src": "30776:20:0" + }, + "variables": [ + { + "name": "var3", + "nativeSrc": "30768:4:0", + "nodeType": "YulTypedName", + "src": "30768:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30817:15:0", + "nodeType": "YulVariableDeclaration", + "src": "30817:15:0", + "value": { + "kind": "number", + "nativeSrc": "30829:3:0", + "nodeType": "YulLiteral", + "src": "30829:3:0", + "type": "", + "value": "0x3" + }, + "variables": [ + { + "name": "var4", + "nativeSrc": "30821:4:0", + "nodeType": "YulTypedName", + "src": "30821:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30853:33:0", + "nodeType": "YulVariableDeclaration", + "src": "30853:33:0", + "value": { + "arguments": [ + { + "name": "var4", + "nativeSrc": "30872:4:0", + "nodeType": "YulIdentifier", + "src": "30872:4:0" + }, + { + "name": "var1", + "nativeSrc": "30878:4:0", + "nodeType": "YulIdentifier", + "src": "30878:4:0" + }, + { + "name": "r", + "nativeSrc": "30884:1:0", + "nodeType": "YulIdentifier", + "src": "30884:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "30865:6:0", + "nodeType": "YulIdentifier", + "src": "30865:6:0" + }, + "nativeSrc": "30865:21:0", + "nodeType": "YulFunctionCall", + "src": "30865:21:0" + }, + "variables": [ + { + "name": "var5", + "nativeSrc": "30857:4:0", + "nodeType": "YulTypedName", + "src": "30857:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30907:33:0", + "nodeType": "YulVariableDeclaration", + "src": "30907:33:0", + "value": { + "arguments": [ + { + "name": "var3", + "nativeSrc": "30926:4:0", + "nodeType": "YulIdentifier", + "src": "30926:4:0" + }, + { + "name": "var5", + "nativeSrc": "30932:4:0", + "nodeType": "YulIdentifier", + "src": "30932:4:0" + }, + { + "name": "r", + "nativeSrc": "30938:1:0", + "nodeType": "YulIdentifier", + "src": "30938:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "30919:6:0", + "nodeType": "YulIdentifier", + "src": "30919:6:0" + }, + "nativeSrc": "30919:21:0", + "nodeType": "YulFunctionCall", + "src": "30919:21:0" + }, + "variables": [ + { + "name": "var6", + "nativeSrc": "30911:4:0", + "nodeType": "YulTypedName", + "src": "30911:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "30961:31:0", + "nodeType": "YulVariableDeclaration", + "src": "30961:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "30985:6:0", + "nodeType": "YulLiteral", + "src": "30985:6:0", + "type": "", + "value": "0x04a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "30972:12:0", + "nodeType": "YulIdentifier", + "src": "30972:12:0" + }, + "nativeSrc": "30972:20:0", + "nodeType": "YulFunctionCall", + "src": "30972:20:0" + }, + "variables": [ + { + "name": "a_2", + "nativeSrc": "30965:3:0", + "nodeType": "YulTypedName", + "src": "30965:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31013:31:0", + "nodeType": "YulVariableDeclaration", + "src": "31013:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "31037:6:0", + "nodeType": "YulLiteral", + "src": "31037:6:0", + "type": "", + "value": "0x0464" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "31024:12:0", + "nodeType": "YulIdentifier", + "src": "31024:12:0" + }, + "nativeSrc": "31024:20:0", + "nodeType": "YulFunctionCall", + "src": "31024:20:0" + }, + "variables": [ + { + "name": "a_0", + "nativeSrc": "31017:3:0", + "nodeType": "YulTypedName", + "src": "31017:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31065:31:0", + "nodeType": "YulVariableDeclaration", + "src": "31065:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "31089:6:0", + "nodeType": "YulLiteral", + "src": "31089:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "31076:12:0", + "nodeType": "YulIdentifier", + "src": "31076:12:0" + }, + "nativeSrc": "31076:20:0", + "nodeType": "YulFunctionCall", + "src": "31076:20:0" + }, + "variables": [ + { + "name": "a_1", + "nativeSrc": "31069:3:0", + "nodeType": "YulTypedName", + "src": "31069:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31117:23:0", + "nodeType": "YulVariableDeclaration", + "src": "31117:23:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "31133:1:0", + "nodeType": "YulIdentifier", + "src": "31133:1:0" + }, + { + "name": "a_1", + "nativeSrc": "31136:3:0", + "nodeType": "YulIdentifier", + "src": "31136:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "31129:3:0", + "nodeType": "YulIdentifier", + "src": "31129:3:0" + }, + "nativeSrc": "31129:11:0", + "nodeType": "YulFunctionCall", + "src": "31129:11:0" + }, + "variables": [ + { + "name": "var7", + "nativeSrc": "31121:4:0", + "nodeType": "YulTypedName", + "src": "31121:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31161:32:0", + "nodeType": "YulVariableDeclaration", + "src": "31161:32:0", + "value": { + "arguments": [ + { + "name": "a_0", + "nativeSrc": "31180:3:0", + "nodeType": "YulIdentifier", + "src": "31180:3:0" + }, + { + "name": "var7", + "nativeSrc": "31185:4:0", + "nodeType": "YulIdentifier", + "src": "31185:4:0" + }, + { + "name": "r", + "nativeSrc": "31191:1:0", + "nodeType": "YulIdentifier", + "src": "31191:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "31173:6:0", + "nodeType": "YulIdentifier", + "src": "31173:6:0" + }, + "nativeSrc": "31173:20:0", + "nodeType": "YulFunctionCall", + "src": "31173:20:0" + }, + "variables": [ + { + "name": "var8", + "nativeSrc": "31165:4:0", + "nodeType": "YulTypedName", + "src": "31165:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31214:24:0", + "nodeType": "YulVariableDeclaration", + "src": "31214:24:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "31230:1:0", + "nodeType": "YulIdentifier", + "src": "31230:1:0" + }, + { + "name": "var8", + "nativeSrc": "31233:4:0", + "nodeType": "YulIdentifier", + "src": "31233:4:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "31226:3:0", + "nodeType": "YulIdentifier", + "src": "31226:3:0" + }, + "nativeSrc": "31226:12:0", + "nodeType": "YulFunctionCall", + "src": "31226:12:0" + }, + "variables": [ + { + "name": "var9", + "nativeSrc": "31218:4:0", + "nodeType": "YulTypedName", + "src": "31218:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31259:33:0", + "nodeType": "YulVariableDeclaration", + "src": "31259:33:0", + "value": { + "arguments": [ + { + "name": "a_2", + "nativeSrc": "31279:3:0", + "nodeType": "YulIdentifier", + "src": "31279:3:0" + }, + { + "name": "var9", + "nativeSrc": "31284:4:0", + "nodeType": "YulIdentifier", + "src": "31284:4:0" + }, + { + "name": "r", + "nativeSrc": "31290:1:0", + "nodeType": "YulIdentifier", + "src": "31290:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "31272:6:0", + "nodeType": "YulIdentifier", + "src": "31272:6:0" + }, + "nativeSrc": "31272:20:0", + "nodeType": "YulFunctionCall", + "src": "31272:20:0" + }, + "variables": [ + { + "name": "var10", + "nativeSrc": "31263:5:0", + "nodeType": "YulTypedName", + "src": "31263:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31313:35:0", + "nodeType": "YulVariableDeclaration", + "src": "31313:35:0", + "value": { + "arguments": [ + { + "name": "var6", + "nativeSrc": "31333:4:0", + "nodeType": "YulIdentifier", + "src": "31333:4:0" + }, + { + "name": "var10", + "nativeSrc": "31339:5:0", + "nodeType": "YulIdentifier", + "src": "31339:5:0" + }, + { + "name": "r", + "nativeSrc": "31346:1:0", + "nodeType": "YulIdentifier", + "src": "31346:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "31326:6:0", + "nodeType": "YulIdentifier", + "src": "31326:6:0" + }, + "nativeSrc": "31326:22:0", + "nodeType": "YulFunctionCall", + "src": "31326:22:0" + }, + "variables": [ + { + "name": "var11", + "nativeSrc": "31317:5:0", + "nodeType": "YulTypedName", + "src": "31317:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31369:74:0", + "nodeType": "YulAssignment", + "src": "31369:74:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "31406:19:0", + "nodeType": "YulIdentifier", + "src": "31406:19:0" + }, + { + "name": "y", + "nativeSrc": "31427:1:0", + "nodeType": "YulIdentifier", + "src": "31427:1:0" + }, + { + "name": "r", + "nativeSrc": "31430:1:0", + "nodeType": "YulIdentifier", + "src": "31430:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "31399:6:0", + "nodeType": "YulIdentifier", + "src": "31399:6:0" + }, + "nativeSrc": "31399:33:0", + "nodeType": "YulFunctionCall", + "src": "31399:33:0" + }, + { + "name": "var11", + "nativeSrc": "31434:5:0", + "nodeType": "YulIdentifier", + "src": "31434:5:0" + }, + { + "name": "r", + "nativeSrc": "31441:1:0", + "nodeType": "YulIdentifier", + "src": "31441:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "31392:6:0", + "nodeType": "YulIdentifier", + "src": "31392:6:0" + }, + "nativeSrc": "31392:51:0", + "nodeType": "YulFunctionCall", + "src": "31392:51:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "31369:19:0", + "nodeType": "YulIdentifier", + "src": "31369:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "31478:872:0", + "nodeType": "YulBlock", + "src": "31478:872:0", + "statements": [ + { + "nativeSrc": "31500:31:0", + "nodeType": "YulVariableDeclaration", + "src": "31500:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "31524:6:0", + "nodeType": "YulLiteral", + "src": "31524:6:0", + "type": "", + "value": "0x0604" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "31511:12:0", + "nodeType": "YulIdentifier", + "src": "31511:12:0" + }, + "nativeSrc": "31511:20:0", + "nodeType": "YulFunctionCall", + "src": "31511:20:0" + }, + "variables": [ + { + "name": "f_9", + "nativeSrc": "31504:3:0", + "nodeType": "YulTypedName", + "src": "31504:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31552:15:0", + "nodeType": "YulVariableDeclaration", + "src": "31552:15:0", + "value": { + "kind": "number", + "nativeSrc": "31564:3:0", + "nodeType": "YulLiteral", + "src": "31564:3:0", + "type": "", + "value": "0x1" + }, + "variables": [ + { + "name": "var0", + "nativeSrc": "31556:4:0", + "nodeType": "YulTypedName", + "src": "31556:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31588:23:0", + "nodeType": "YulVariableDeclaration", + "src": "31588:23:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "31604:1:0", + "nodeType": "YulIdentifier", + "src": "31604:1:0" + }, + { + "name": "f_9", + "nativeSrc": "31607:3:0", + "nodeType": "YulIdentifier", + "src": "31607:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "31600:3:0", + "nodeType": "YulIdentifier", + "src": "31600:3:0" + }, + "nativeSrc": "31600:11:0", + "nodeType": "YulFunctionCall", + "src": "31600:11:0" + }, + "variables": [ + { + "name": "var1", + "nativeSrc": "31592:4:0", + "nodeType": "YulTypedName", + "src": "31592:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31632:33:0", + "nodeType": "YulVariableDeclaration", + "src": "31632:33:0", + "value": { + "arguments": [ + { + "name": "var0", + "nativeSrc": "31651:4:0", + "nodeType": "YulIdentifier", + "src": "31651:4:0" + }, + { + "name": "var1", + "nativeSrc": "31657:4:0", + "nodeType": "YulIdentifier", + "src": "31657:4:0" + }, + { + "name": "r", + "nativeSrc": "31663:1:0", + "nodeType": "YulIdentifier", + "src": "31663:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "31644:6:0", + "nodeType": "YulIdentifier", + "src": "31644:6:0" + }, + "nativeSrc": "31644:21:0", + "nodeType": "YulFunctionCall", + "src": "31644:21:0" + }, + "variables": [ + { + "name": "var2", + "nativeSrc": "31636:4:0", + "nodeType": "YulTypedName", + "src": "31636:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31686:32:0", + "nodeType": "YulVariableDeclaration", + "src": "31686:32:0", + "value": { + "arguments": [ + { + "name": "f_9", + "nativeSrc": "31705:3:0", + "nodeType": "YulIdentifier", + "src": "31705:3:0" + }, + { + "name": "var2", + "nativeSrc": "31710:4:0", + "nodeType": "YulIdentifier", + "src": "31710:4:0" + }, + { + "name": "r", + "nativeSrc": "31716:1:0", + "nodeType": "YulIdentifier", + "src": "31716:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "31698:6:0", + "nodeType": "YulIdentifier", + "src": "31698:6:0" + }, + "nativeSrc": "31698:20:0", + "nodeType": "YulFunctionCall", + "src": "31698:20:0" + }, + "variables": [ + { + "name": "var3", + "nativeSrc": "31690:4:0", + "nodeType": "YulTypedName", + "src": "31690:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31739:15:0", + "nodeType": "YulVariableDeclaration", + "src": "31739:15:0", + "value": { + "kind": "number", + "nativeSrc": "31751:3:0", + "nodeType": "YulLiteral", + "src": "31751:3:0", + "type": "", + "value": "0x3" + }, + "variables": [ + { + "name": "var4", + "nativeSrc": "31743:4:0", + "nodeType": "YulTypedName", + "src": "31743:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31775:33:0", + "nodeType": "YulVariableDeclaration", + "src": "31775:33:0", + "value": { + "arguments": [ + { + "name": "var4", + "nativeSrc": "31794:4:0", + "nodeType": "YulIdentifier", + "src": "31794:4:0" + }, + { + "name": "var1", + "nativeSrc": "31800:4:0", + "nodeType": "YulIdentifier", + "src": "31800:4:0" + }, + { + "name": "r", + "nativeSrc": "31806:1:0", + "nodeType": "YulIdentifier", + "src": "31806:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "31787:6:0", + "nodeType": "YulIdentifier", + "src": "31787:6:0" + }, + "nativeSrc": "31787:21:0", + "nodeType": "YulFunctionCall", + "src": "31787:21:0" + }, + "variables": [ + { + "name": "var5", + "nativeSrc": "31779:4:0", + "nodeType": "YulTypedName", + "src": "31779:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31829:33:0", + "nodeType": "YulVariableDeclaration", + "src": "31829:33:0", + "value": { + "arguments": [ + { + "name": "var3", + "nativeSrc": "31848:4:0", + "nodeType": "YulIdentifier", + "src": "31848:4:0" + }, + { + "name": "var5", + "nativeSrc": "31854:4:0", + "nodeType": "YulIdentifier", + "src": "31854:4:0" + }, + { + "name": "r", + "nativeSrc": "31860:1:0", + "nodeType": "YulIdentifier", + "src": "31860:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "31841:6:0", + "nodeType": "YulIdentifier", + "src": "31841:6:0" + }, + "nativeSrc": "31841:21:0", + "nodeType": "YulFunctionCall", + "src": "31841:21:0" + }, + "variables": [ + { + "name": "var6", + "nativeSrc": "31833:4:0", + "nodeType": "YulTypedName", + "src": "31833:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31883:31:0", + "nodeType": "YulVariableDeclaration", + "src": "31883:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "31907:6:0", + "nodeType": "YulLiteral", + "src": "31907:6:0", + "type": "", + "value": "0x04a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "31894:12:0", + "nodeType": "YulIdentifier", + "src": "31894:12:0" + }, + "nativeSrc": "31894:20:0", + "nodeType": "YulFunctionCall", + "src": "31894:20:0" + }, + "variables": [ + { + "name": "a_2", + "nativeSrc": "31887:3:0", + "nodeType": "YulTypedName", + "src": "31887:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31935:31:0", + "nodeType": "YulVariableDeclaration", + "src": "31935:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "31959:6:0", + "nodeType": "YulLiteral", + "src": "31959:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "31946:12:0", + "nodeType": "YulIdentifier", + "src": "31946:12:0" + }, + "nativeSrc": "31946:20:0", + "nodeType": "YulFunctionCall", + "src": "31946:20:0" + }, + "variables": [ + { + "name": "a_1", + "nativeSrc": "31939:3:0", + "nodeType": "YulTypedName", + "src": "31939:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "31987:38:0", + "nodeType": "YulVariableDeclaration", + "src": "31987:38:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "32018:6:0", + "nodeType": "YulLiteral", + "src": "32018:6:0", + "type": "", + "value": "0x04c4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "32005:12:0", + "nodeType": "YulIdentifier", + "src": "32005:12:0" + }, + "nativeSrc": "32005:20:0", + "nodeType": "YulFunctionCall", + "src": "32005:20:0" + }, + "variables": [ + { + "name": "a_2_prev_1", + "nativeSrc": "31991:10:0", + "nodeType": "YulTypedName", + "src": "31991:10:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32046:38:0", + "nodeType": "YulVariableDeclaration", + "src": "32046:38:0", + "value": { + "arguments": [ + { + "name": "a_1", + "nativeSrc": "32065:3:0", + "nodeType": "YulIdentifier", + "src": "32065:3:0" + }, + { + "name": "a_2_prev_1", + "nativeSrc": "32070:10:0", + "nodeType": "YulIdentifier", + "src": "32070:10:0" + }, + { + "name": "r", + "nativeSrc": "32082:1:0", + "nodeType": "YulIdentifier", + "src": "32082:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "32058:6:0", + "nodeType": "YulIdentifier", + "src": "32058:6:0" + }, + "nativeSrc": "32058:26:0", + "nodeType": "YulFunctionCall", + "src": "32058:26:0" + }, + "variables": [ + { + "name": "var7", + "nativeSrc": "32050:4:0", + "nodeType": "YulTypedName", + "src": "32050:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32105:24:0", + "nodeType": "YulVariableDeclaration", + "src": "32105:24:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "32121:1:0", + "nodeType": "YulIdentifier", + "src": "32121:1:0" + }, + { + "name": "var7", + "nativeSrc": "32124:4:0", + "nodeType": "YulIdentifier", + "src": "32124:4:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "32117:3:0", + "nodeType": "YulIdentifier", + "src": "32117:3:0" + }, + "nativeSrc": "32117:12:0", + "nodeType": "YulFunctionCall", + "src": "32117:12:0" + }, + "variables": [ + { + "name": "var8", + "nativeSrc": "32109:4:0", + "nodeType": "YulTypedName", + "src": "32109:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32150:32:0", + "nodeType": "YulVariableDeclaration", + "src": "32150:32:0", + "value": { + "arguments": [ + { + "name": "a_2", + "nativeSrc": "32169:3:0", + "nodeType": "YulIdentifier", + "src": "32169:3:0" + }, + { + "name": "var8", + "nativeSrc": "32174:4:0", + "nodeType": "YulIdentifier", + "src": "32174:4:0" + }, + { + "name": "r", + "nativeSrc": "32180:1:0", + "nodeType": "YulIdentifier", + "src": "32180:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "32162:6:0", + "nodeType": "YulIdentifier", + "src": "32162:6:0" + }, + "nativeSrc": "32162:20:0", + "nodeType": "YulFunctionCall", + "src": "32162:20:0" + }, + "variables": [ + { + "name": "var9", + "nativeSrc": "32154:4:0", + "nodeType": "YulTypedName", + "src": "32154:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32203:34:0", + "nodeType": "YulVariableDeclaration", + "src": "32203:34:0", + "value": { + "arguments": [ + { + "name": "var6", + "nativeSrc": "32223:4:0", + "nodeType": "YulIdentifier", + "src": "32223:4:0" + }, + { + "name": "var9", + "nativeSrc": "32229:4:0", + "nodeType": "YulIdentifier", + "src": "32229:4:0" + }, + { + "name": "r", + "nativeSrc": "32235:1:0", + "nodeType": "YulIdentifier", + "src": "32235:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "32216:6:0", + "nodeType": "YulIdentifier", + "src": "32216:6:0" + }, + "nativeSrc": "32216:21:0", + "nodeType": "YulFunctionCall", + "src": "32216:21:0" + }, + "variables": [ + { + "name": "var10", + "nativeSrc": "32207:5:0", + "nodeType": "YulTypedName", + "src": "32207:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32258:74:0", + "nodeType": "YulAssignment", + "src": "32258:74:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "32295:19:0", + "nodeType": "YulIdentifier", + "src": "32295:19:0" + }, + { + "name": "y", + "nativeSrc": "32316:1:0", + "nodeType": "YulIdentifier", + "src": "32316:1:0" + }, + { + "name": "r", + "nativeSrc": "32319:1:0", + "nodeType": "YulIdentifier", + "src": "32319:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "32288:6:0", + "nodeType": "YulIdentifier", + "src": "32288:6:0" + }, + "nativeSrc": "32288:33:0", + "nodeType": "YulFunctionCall", + "src": "32288:33:0" + }, + { + "name": "var10", + "nativeSrc": "32323:5:0", + "nodeType": "YulIdentifier", + "src": "32323:5:0" + }, + { + "name": "r", + "nativeSrc": "32330:1:0", + "nodeType": "YulIdentifier", + "src": "32330:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "32281:6:0", + "nodeType": "YulIdentifier", + "src": "32281:6:0" + }, + "nativeSrc": "32281:51:0", + "nodeType": "YulFunctionCall", + "src": "32281:51:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "32258:19:0", + "nodeType": "YulIdentifier", + "src": "32258:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "32367:798:0", + "nodeType": "YulBlock", + "src": "32367:798:0", + "statements": [ + { + "nativeSrc": "32389:31:0", + "nodeType": "YulVariableDeclaration", + "src": "32389:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "32413:6:0", + "nodeType": "YulLiteral", + "src": "32413:6:0", + "type": "", + "value": "0x0604" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "32400:12:0", + "nodeType": "YulIdentifier", + "src": "32400:12:0" + }, + "nativeSrc": "32400:20:0", + "nodeType": "YulFunctionCall", + "src": "32400:20:0" + }, + "variables": [ + { + "name": "f_9", + "nativeSrc": "32393:3:0", + "nodeType": "YulTypedName", + "src": "32393:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32441:15:0", + "nodeType": "YulVariableDeclaration", + "src": "32441:15:0", + "value": { + "kind": "number", + "nativeSrc": "32453:3:0", + "nodeType": "YulLiteral", + "src": "32453:3:0", + "type": "", + "value": "0x1" + }, + "variables": [ + { + "name": "var0", + "nativeSrc": "32445:4:0", + "nodeType": "YulTypedName", + "src": "32445:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32477:23:0", + "nodeType": "YulVariableDeclaration", + "src": "32477:23:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "32493:1:0", + "nodeType": "YulIdentifier", + "src": "32493:1:0" + }, + { + "name": "f_9", + "nativeSrc": "32496:3:0", + "nodeType": "YulIdentifier", + "src": "32496:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "32489:3:0", + "nodeType": "YulIdentifier", + "src": "32489:3:0" + }, + "nativeSrc": "32489:11:0", + "nodeType": "YulFunctionCall", + "src": "32489:11:0" + }, + "variables": [ + { + "name": "var1", + "nativeSrc": "32481:4:0", + "nodeType": "YulTypedName", + "src": "32481:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32521:33:0", + "nodeType": "YulVariableDeclaration", + "src": "32521:33:0", + "value": { + "arguments": [ + { + "name": "var0", + "nativeSrc": "32540:4:0", + "nodeType": "YulIdentifier", + "src": "32540:4:0" + }, + { + "name": "var1", + "nativeSrc": "32546:4:0", + "nodeType": "YulIdentifier", + "src": "32546:4:0" + }, + { + "name": "r", + "nativeSrc": "32552:1:0", + "nodeType": "YulIdentifier", + "src": "32552:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "32533:6:0", + "nodeType": "YulIdentifier", + "src": "32533:6:0" + }, + "nativeSrc": "32533:21:0", + "nodeType": "YulFunctionCall", + "src": "32533:21:0" + }, + "variables": [ + { + "name": "var2", + "nativeSrc": "32525:4:0", + "nodeType": "YulTypedName", + "src": "32525:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32575:32:0", + "nodeType": "YulVariableDeclaration", + "src": "32575:32:0", + "value": { + "arguments": [ + { + "name": "f_9", + "nativeSrc": "32594:3:0", + "nodeType": "YulIdentifier", + "src": "32594:3:0" + }, + { + "name": "var2", + "nativeSrc": "32599:4:0", + "nodeType": "YulIdentifier", + "src": "32599:4:0" + }, + { + "name": "r", + "nativeSrc": "32605:1:0", + "nodeType": "YulIdentifier", + "src": "32605:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "32587:6:0", + "nodeType": "YulIdentifier", + "src": "32587:6:0" + }, + "nativeSrc": "32587:20:0", + "nodeType": "YulFunctionCall", + "src": "32587:20:0" + }, + "variables": [ + { + "name": "var3", + "nativeSrc": "32579:4:0", + "nodeType": "YulTypedName", + "src": "32579:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32628:15:0", + "nodeType": "YulVariableDeclaration", + "src": "32628:15:0", + "value": { + "kind": "number", + "nativeSrc": "32640:3:0", + "nodeType": "YulLiteral", + "src": "32640:3:0", + "type": "", + "value": "0x2" + }, + "variables": [ + { + "name": "var4", + "nativeSrc": "32632:4:0", + "nodeType": "YulTypedName", + "src": "32632:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32664:33:0", + "nodeType": "YulVariableDeclaration", + "src": "32664:33:0", + "value": { + "arguments": [ + { + "name": "var4", + "nativeSrc": "32683:4:0", + "nodeType": "YulIdentifier", + "src": "32683:4:0" + }, + { + "name": "var1", + "nativeSrc": "32689:4:0", + "nodeType": "YulIdentifier", + "src": "32689:4:0" + }, + { + "name": "r", + "nativeSrc": "32695:1:0", + "nodeType": "YulIdentifier", + "src": "32695:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "32676:6:0", + "nodeType": "YulIdentifier", + "src": "32676:6:0" + }, + "nativeSrc": "32676:21:0", + "nodeType": "YulFunctionCall", + "src": "32676:21:0" + }, + "variables": [ + { + "name": "var5", + "nativeSrc": "32668:4:0", + "nodeType": "YulTypedName", + "src": "32668:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32718:33:0", + "nodeType": "YulVariableDeclaration", + "src": "32718:33:0", + "value": { + "arguments": [ + { + "name": "var3", + "nativeSrc": "32737:4:0", + "nodeType": "YulIdentifier", + "src": "32737:4:0" + }, + { + "name": "var5", + "nativeSrc": "32743:4:0", + "nodeType": "YulIdentifier", + "src": "32743:4:0" + }, + { + "name": "r", + "nativeSrc": "32749:1:0", + "nodeType": "YulIdentifier", + "src": "32749:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "32730:6:0", + "nodeType": "YulIdentifier", + "src": "32730:6:0" + }, + "nativeSrc": "32730:21:0", + "nodeType": "YulFunctionCall", + "src": "32730:21:0" + }, + "variables": [ + { + "name": "var6", + "nativeSrc": "32722:4:0", + "nodeType": "YulTypedName", + "src": "32722:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32772:31:0", + "nodeType": "YulVariableDeclaration", + "src": "32772:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "32796:6:0", + "nodeType": "YulLiteral", + "src": "32796:6:0", + "type": "", + "value": "0x04a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "32783:12:0", + "nodeType": "YulIdentifier", + "src": "32783:12:0" + }, + "nativeSrc": "32783:20:0", + "nodeType": "YulFunctionCall", + "src": "32783:20:0" + }, + "variables": [ + { + "name": "a_2", + "nativeSrc": "32776:3:0", + "nodeType": "YulTypedName", + "src": "32776:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32824:31:0", + "nodeType": "YulVariableDeclaration", + "src": "32824:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "32848:6:0", + "nodeType": "YulLiteral", + "src": "32848:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "32835:12:0", + "nodeType": "YulIdentifier", + "src": "32835:12:0" + }, + "nativeSrc": "32835:20:0", + "nodeType": "YulFunctionCall", + "src": "32835:20:0" + }, + "variables": [ + { + "name": "a_1", + "nativeSrc": "32828:3:0", + "nodeType": "YulTypedName", + "src": "32828:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32876:23:0", + "nodeType": "YulVariableDeclaration", + "src": "32876:23:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "32892:1:0", + "nodeType": "YulIdentifier", + "src": "32892:1:0" + }, + { + "name": "a_1", + "nativeSrc": "32895:3:0", + "nodeType": "YulIdentifier", + "src": "32895:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "32888:3:0", + "nodeType": "YulIdentifier", + "src": "32888:3:0" + }, + "nativeSrc": "32888:11:0", + "nodeType": "YulFunctionCall", + "src": "32888:11:0" + }, + "variables": [ + { + "name": "var7", + "nativeSrc": "32880:4:0", + "nodeType": "YulTypedName", + "src": "32880:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32920:24:0", + "nodeType": "YulVariableDeclaration", + "src": "32920:24:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "32936:1:0", + "nodeType": "YulIdentifier", + "src": "32936:1:0" + }, + { + "name": "var7", + "nativeSrc": "32939:4:0", + "nodeType": "YulIdentifier", + "src": "32939:4:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "32932:3:0", + "nodeType": "YulIdentifier", + "src": "32932:3:0" + }, + "nativeSrc": "32932:12:0", + "nodeType": "YulFunctionCall", + "src": "32932:12:0" + }, + "variables": [ + { + "name": "var8", + "nativeSrc": "32924:4:0", + "nodeType": "YulTypedName", + "src": "32924:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "32965:32:0", + "nodeType": "YulVariableDeclaration", + "src": "32965:32:0", + "value": { + "arguments": [ + { + "name": "a_2", + "nativeSrc": "32984:3:0", + "nodeType": "YulIdentifier", + "src": "32984:3:0" + }, + { + "name": "var8", + "nativeSrc": "32989:4:0", + "nodeType": "YulIdentifier", + "src": "32989:4:0" + }, + { + "name": "r", + "nativeSrc": "32995:1:0", + "nodeType": "YulIdentifier", + "src": "32995:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "32977:6:0", + "nodeType": "YulIdentifier", + "src": "32977:6:0" + }, + "nativeSrc": "32977:20:0", + "nodeType": "YulFunctionCall", + "src": "32977:20:0" + }, + "variables": [ + { + "name": "var9", + "nativeSrc": "32969:4:0", + "nodeType": "YulTypedName", + "src": "32969:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33018:34:0", + "nodeType": "YulVariableDeclaration", + "src": "33018:34:0", + "value": { + "arguments": [ + { + "name": "var6", + "nativeSrc": "33038:4:0", + "nodeType": "YulIdentifier", + "src": "33038:4:0" + }, + { + "name": "var9", + "nativeSrc": "33044:4:0", + "nodeType": "YulIdentifier", + "src": "33044:4:0" + }, + { + "name": "r", + "nativeSrc": "33050:1:0", + "nodeType": "YulIdentifier", + "src": "33050:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "33031:6:0", + "nodeType": "YulIdentifier", + "src": "33031:6:0" + }, + "nativeSrc": "33031:21:0", + "nodeType": "YulFunctionCall", + "src": "33031:21:0" + }, + "variables": [ + { + "name": "var10", + "nativeSrc": "33022:5:0", + "nodeType": "YulTypedName", + "src": "33022:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33073:74:0", + "nodeType": "YulAssignment", + "src": "33073:74:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "33110:19:0", + "nodeType": "YulIdentifier", + "src": "33110:19:0" + }, + { + "name": "y", + "nativeSrc": "33131:1:0", + "nodeType": "YulIdentifier", + "src": "33131:1:0" + }, + { + "name": "r", + "nativeSrc": "33134:1:0", + "nodeType": "YulIdentifier", + "src": "33134:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "33103:6:0", + "nodeType": "YulIdentifier", + "src": "33103:6:0" + }, + "nativeSrc": "33103:33:0", + "nodeType": "YulFunctionCall", + "src": "33103:33:0" + }, + { + "name": "var10", + "nativeSrc": "33138:5:0", + "nodeType": "YulIdentifier", + "src": "33138:5:0" + }, + { + "name": "r", + "nativeSrc": "33145:1:0", + "nodeType": "YulIdentifier", + "src": "33145:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "33096:6:0", + "nodeType": "YulIdentifier", + "src": "33096:6:0" + }, + "nativeSrc": "33096:51:0", + "nodeType": "YulFunctionCall", + "src": "33096:51:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "33073:19:0", + "nodeType": "YulIdentifier", + "src": "33073:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "33182:604:0", + "nodeType": "YulBlock", + "src": "33182:604:0", + "statements": [ + { + "nativeSrc": "33204:32:0", + "nodeType": "YulVariableDeclaration", + "src": "33204:32:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "33229:6:0", + "nodeType": "YulLiteral", + "src": "33229:6:0", + "type": "", + "value": "0x0624" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "33216:12:0", + "nodeType": "YulIdentifier", + "src": "33216:12:0" + }, + "nativeSrc": "33216:20:0", + "nodeType": "YulFunctionCall", + "src": "33216:20:0" + }, + "variables": [ + { + "name": "f_10", + "nativeSrc": "33208:4:0", + "nodeType": "YulTypedName", + "src": "33208:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33257:15:0", + "nodeType": "YulVariableDeclaration", + "src": "33257:15:0", + "value": { + "kind": "number", + "nativeSrc": "33269:3:0", + "nodeType": "YulLiteral", + "src": "33269:3:0", + "type": "", + "value": "0x1" + }, + "variables": [ + { + "name": "var0", + "nativeSrc": "33261:4:0", + "nodeType": "YulTypedName", + "src": "33261:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33293:24:0", + "nodeType": "YulVariableDeclaration", + "src": "33293:24:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "33309:1:0", + "nodeType": "YulIdentifier", + "src": "33309:1:0" + }, + { + "name": "f_10", + "nativeSrc": "33312:4:0", + "nodeType": "YulIdentifier", + "src": "33312:4:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "33305:3:0", + "nodeType": "YulIdentifier", + "src": "33305:3:0" + }, + "nativeSrc": "33305:12:0", + "nodeType": "YulFunctionCall", + "src": "33305:12:0" + }, + "variables": [ + { + "name": "var1", + "nativeSrc": "33297:4:0", + "nodeType": "YulTypedName", + "src": "33297:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33338:33:0", + "nodeType": "YulVariableDeclaration", + "src": "33338:33:0", + "value": { + "arguments": [ + { + "name": "var0", + "nativeSrc": "33357:4:0", + "nodeType": "YulIdentifier", + "src": "33357:4:0" + }, + { + "name": "var1", + "nativeSrc": "33363:4:0", + "nodeType": "YulIdentifier", + "src": "33363:4:0" + }, + { + "name": "r", + "nativeSrc": "33369:1:0", + "nodeType": "YulIdentifier", + "src": "33369:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "33350:6:0", + "nodeType": "YulIdentifier", + "src": "33350:6:0" + }, + "nativeSrc": "33350:21:0", + "nodeType": "YulFunctionCall", + "src": "33350:21:0" + }, + "variables": [ + { + "name": "var2", + "nativeSrc": "33342:4:0", + "nodeType": "YulTypedName", + "src": "33342:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33392:33:0", + "nodeType": "YulVariableDeclaration", + "src": "33392:33:0", + "value": { + "arguments": [ + { + "name": "f_10", + "nativeSrc": "33411:4:0", + "nodeType": "YulIdentifier", + "src": "33411:4:0" + }, + { + "name": "var2", + "nativeSrc": "33417:4:0", + "nodeType": "YulIdentifier", + "src": "33417:4:0" + }, + { + "name": "r", + "nativeSrc": "33423:1:0", + "nodeType": "YulIdentifier", + "src": "33423:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "33404:6:0", + "nodeType": "YulIdentifier", + "src": "33404:6:0" + }, + "nativeSrc": "33404:21:0", + "nodeType": "YulFunctionCall", + "src": "33404:21:0" + }, + "variables": [ + { + "name": "var3", + "nativeSrc": "33396:4:0", + "nodeType": "YulTypedName", + "src": "33396:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33446:15:0", + "nodeType": "YulVariableDeclaration", + "src": "33446:15:0", + "value": { + "kind": "number", + "nativeSrc": "33458:3:0", + "nodeType": "YulLiteral", + "src": "33458:3:0", + "type": "", + "value": "0x3" + }, + "variables": [ + { + "name": "var4", + "nativeSrc": "33450:4:0", + "nodeType": "YulTypedName", + "src": "33450:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33482:33:0", + "nodeType": "YulVariableDeclaration", + "src": "33482:33:0", + "value": { + "arguments": [ + { + "name": "var4", + "nativeSrc": "33501:4:0", + "nodeType": "YulIdentifier", + "src": "33501:4:0" + }, + { + "name": "var1", + "nativeSrc": "33507:4:0", + "nodeType": "YulIdentifier", + "src": "33507:4:0" + }, + { + "name": "r", + "nativeSrc": "33513:1:0", + "nodeType": "YulIdentifier", + "src": "33513:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "33494:6:0", + "nodeType": "YulIdentifier", + "src": "33494:6:0" + }, + "nativeSrc": "33494:21:0", + "nodeType": "YulFunctionCall", + "src": "33494:21:0" + }, + "variables": [ + { + "name": "var5", + "nativeSrc": "33486:4:0", + "nodeType": "YulTypedName", + "src": "33486:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33536:33:0", + "nodeType": "YulVariableDeclaration", + "src": "33536:33:0", + "value": { + "arguments": [ + { + "name": "var3", + "nativeSrc": "33555:4:0", + "nodeType": "YulIdentifier", + "src": "33555:4:0" + }, + { + "name": "var5", + "nativeSrc": "33561:4:0", + "nodeType": "YulIdentifier", + "src": "33561:4:0" + }, + { + "name": "r", + "nativeSrc": "33567:1:0", + "nodeType": "YulIdentifier", + "src": "33567:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "33548:6:0", + "nodeType": "YulIdentifier", + "src": "33548:6:0" + }, + "nativeSrc": "33548:21:0", + "nodeType": "YulFunctionCall", + "src": "33548:21:0" + }, + "variables": [ + { + "name": "var6", + "nativeSrc": "33540:4:0", + "nodeType": "YulTypedName", + "src": "33540:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33590:31:0", + "nodeType": "YulVariableDeclaration", + "src": "33590:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "33614:6:0", + "nodeType": "YulLiteral", + "src": "33614:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "33601:12:0", + "nodeType": "YulIdentifier", + "src": "33601:12:0" + }, + "nativeSrc": "33601:20:0", + "nodeType": "YulFunctionCall", + "src": "33601:20:0" + }, + "variables": [ + { + "name": "a_1", + "nativeSrc": "33594:3:0", + "nodeType": "YulTypedName", + "src": "33594:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33642:32:0", + "nodeType": "YulVariableDeclaration", + "src": "33642:32:0", + "value": { + "arguments": [ + { + "name": "var6", + "nativeSrc": "33661:4:0", + "nodeType": "YulIdentifier", + "src": "33661:4:0" + }, + { + "name": "a_1", + "nativeSrc": "33667:3:0", + "nodeType": "YulIdentifier", + "src": "33667:3:0" + }, + { + "name": "r", + "nativeSrc": "33672:1:0", + "nodeType": "YulIdentifier", + "src": "33672:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "33654:6:0", + "nodeType": "YulIdentifier", + "src": "33654:6:0" + }, + "nativeSrc": "33654:20:0", + "nodeType": "YulFunctionCall", + "src": "33654:20:0" + }, + "variables": [ + { + "name": "var7", + "nativeSrc": "33646:4:0", + "nodeType": "YulTypedName", + "src": "33646:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33695:73:0", + "nodeType": "YulAssignment", + "src": "33695:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "33732:19:0", + "nodeType": "YulIdentifier", + "src": "33732:19:0" + }, + { + "name": "y", + "nativeSrc": "33753:1:0", + "nodeType": "YulIdentifier", + "src": "33753:1:0" + }, + { + "name": "r", + "nativeSrc": "33756:1:0", + "nodeType": "YulIdentifier", + "src": "33756:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "33725:6:0", + "nodeType": "YulIdentifier", + "src": "33725:6:0" + }, + "nativeSrc": "33725:33:0", + "nodeType": "YulFunctionCall", + "src": "33725:33:0" + }, + { + "name": "var7", + "nativeSrc": "33760:4:0", + "nodeType": "YulIdentifier", + "src": "33760:4:0" + }, + { + "name": "r", + "nativeSrc": "33766:1:0", + "nodeType": "YulIdentifier", + "src": "33766:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "33718:6:0", + "nodeType": "YulIdentifier", + "src": "33718:6:0" + }, + "nativeSrc": "33718:50:0", + "nodeType": "YulFunctionCall", + "src": "33718:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "33695:19:0", + "nodeType": "YulIdentifier", + "src": "33695:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "33803:459:0", + "nodeType": "YulBlock", + "src": "33803:459:0", + "statements": [ + { + "nativeSrc": "33825:32:0", + "nodeType": "YulVariableDeclaration", + "src": "33825:32:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "33850:6:0", + "nodeType": "YulLiteral", + "src": "33850:6:0", + "type": "", + "value": "0x0644" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "33837:12:0", + "nodeType": "YulIdentifier", + "src": "33837:12:0" + }, + "nativeSrc": "33837:20:0", + "nodeType": "YulFunctionCall", + "src": "33837:20:0" + }, + "variables": [ + { + "name": "f_11", + "nativeSrc": "33829:4:0", + "nodeType": "YulTypedName", + "src": "33829:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33878:31:0", + "nodeType": "YulVariableDeclaration", + "src": "33878:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "33902:6:0", + "nodeType": "YulLiteral", + "src": "33902:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "33889:12:0", + "nodeType": "YulIdentifier", + "src": "33889:12:0" + }, + "nativeSrc": "33889:20:0", + "nodeType": "YulFunctionCall", + "src": "33889:20:0" + }, + "variables": [ + { + "name": "a_1", + "nativeSrc": "33882:3:0", + "nodeType": "YulTypedName", + "src": "33882:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33930:15:0", + "nodeType": "YulVariableDeclaration", + "src": "33930:15:0", + "value": { + "kind": "number", + "nativeSrc": "33942:3:0", + "nodeType": "YulLiteral", + "src": "33942:3:0", + "type": "", + "value": "0x1" + }, + "variables": [ + { + "name": "var0", + "nativeSrc": "33934:4:0", + "nodeType": "YulTypedName", + "src": "33934:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "33966:24:0", + "nodeType": "YulVariableDeclaration", + "src": "33966:24:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "33982:1:0", + "nodeType": "YulIdentifier", + "src": "33982:1:0" + }, + { + "name": "var0", + "nativeSrc": "33985:4:0", + "nodeType": "YulIdentifier", + "src": "33985:4:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "33978:3:0", + "nodeType": "YulIdentifier", + "src": "33978:3:0" + }, + "nativeSrc": "33978:12:0", + "nodeType": "YulFunctionCall", + "src": "33978:12:0" + }, + "variables": [ + { + "name": "var1", + "nativeSrc": "33970:4:0", + "nodeType": "YulTypedName", + "src": "33970:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "34011:32:0", + "nodeType": "YulVariableDeclaration", + "src": "34011:32:0", + "value": { + "arguments": [ + { + "name": "a_1", + "nativeSrc": "34030:3:0", + "nodeType": "YulIdentifier", + "src": "34030:3:0" + }, + { + "name": "var1", + "nativeSrc": "34035:4:0", + "nodeType": "YulIdentifier", + "src": "34035:4:0" + }, + { + "name": "r", + "nativeSrc": "34041:1:0", + "nodeType": "YulIdentifier", + "src": "34041:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "34023:6:0", + "nodeType": "YulIdentifier", + "src": "34023:6:0" + }, + "nativeSrc": "34023:20:0", + "nodeType": "YulFunctionCall", + "src": "34023:20:0" + }, + "variables": [ + { + "name": "var2", + "nativeSrc": "34015:4:0", + "nodeType": "YulTypedName", + "src": "34015:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "34064:32:0", + "nodeType": "YulVariableDeclaration", + "src": "34064:32:0", + "value": { + "arguments": [ + { + "name": "a_1", + "nativeSrc": "34083:3:0", + "nodeType": "YulIdentifier", + "src": "34083:3:0" + }, + { + "name": "var2", + "nativeSrc": "34088:4:0", + "nodeType": "YulIdentifier", + "src": "34088:4:0" + }, + { + "name": "r", + "nativeSrc": "34094:1:0", + "nodeType": "YulIdentifier", + "src": "34094:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "34076:6:0", + "nodeType": "YulIdentifier", + "src": "34076:6:0" + }, + "nativeSrc": "34076:20:0", + "nodeType": "YulFunctionCall", + "src": "34076:20:0" + }, + "variables": [ + { + "name": "var3", + "nativeSrc": "34068:4:0", + "nodeType": "YulTypedName", + "src": "34068:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "34117:33:0", + "nodeType": "YulVariableDeclaration", + "src": "34117:33:0", + "value": { + "arguments": [ + { + "name": "f_11", + "nativeSrc": "34136:4:0", + "nodeType": "YulIdentifier", + "src": "34136:4:0" + }, + { + "name": "var3", + "nativeSrc": "34142:4:0", + "nodeType": "YulIdentifier", + "src": "34142:4:0" + }, + { + "name": "r", + "nativeSrc": "34148:1:0", + "nodeType": "YulIdentifier", + "src": "34148:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "34129:6:0", + "nodeType": "YulIdentifier", + "src": "34129:6:0" + }, + "nativeSrc": "34129:21:0", + "nodeType": "YulFunctionCall", + "src": "34129:21:0" + }, + "variables": [ + { + "name": "var4", + "nativeSrc": "34121:4:0", + "nodeType": "YulTypedName", + "src": "34121:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "34171:73:0", + "nodeType": "YulAssignment", + "src": "34171:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "34208:19:0", + "nodeType": "YulIdentifier", + "src": "34208:19:0" + }, + { + "name": "y", + "nativeSrc": "34229:1:0", + "nodeType": "YulIdentifier", + "src": "34229:1:0" + }, + { + "name": "r", + "nativeSrc": "34232:1:0", + "nodeType": "YulIdentifier", + "src": "34232:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "34201:6:0", + "nodeType": "YulIdentifier", + "src": "34201:6:0" + }, + "nativeSrc": "34201:33:0", + "nodeType": "YulFunctionCall", + "src": "34201:33:0" + }, + { + "name": "var4", + "nativeSrc": "34236:4:0", + "nodeType": "YulIdentifier", + "src": "34236:4:0" + }, + { + "name": "r", + "nativeSrc": "34242:1:0", + "nodeType": "YulIdentifier", + "src": "34242:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "34194:6:0", + "nodeType": "YulIdentifier", + "src": "34194:6:0" + }, + "nativeSrc": "34194:50:0", + "nodeType": "YulFunctionCall", + "src": "34194:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "34171:19:0", + "nodeType": "YulIdentifier", + "src": "34171:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "34279:253:0", + "nodeType": "YulBlock", + "src": "34279:253:0", + "statements": [ + { + "nativeSrc": "34301:26:0", + "nodeType": "YulVariableDeclaration", + "src": "34301:26:0", + "value": { + "arguments": [ + { + "name": "L_0_MPTR", + "nativeSrc": "34318:8:0", + "nodeType": "YulIdentifier", + "src": "34318:8:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "34312:5:0", + "nodeType": "YulIdentifier", + "src": "34312:5:0" + }, + "nativeSrc": "34312:15:0", + "nodeType": "YulFunctionCall", + "src": "34312:15:0" + }, + "variables": [ + { + "name": "l_0", + "nativeSrc": "34305:3:0", + "nodeType": "YulTypedName", + "src": "34305:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "34348:72:0", + "nodeType": "YulVariableDeclaration", + "src": "34348:72:0", + "value": { + "arguments": [ + { + "name": "l_0", + "nativeSrc": "34367:3:0", + "nodeType": "YulIdentifier", + "src": "34367:3:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "34376:1:0", + "nodeType": "YulIdentifier", + "src": "34376:1:0" + }, + { + "arguments": [ + { + "name": "l_0", + "nativeSrc": "34386:3:0", + "nodeType": "YulIdentifier", + "src": "34386:3:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "34404:6:0", + "nodeType": "YulLiteral", + "src": "34404:6:0", + "type": "", + "value": "0x0724" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "34391:12:0", + "nodeType": "YulIdentifier", + "src": "34391:12:0" + }, + "nativeSrc": "34391:20:0", + "nodeType": "YulFunctionCall", + "src": "34391:20:0" + }, + { + "name": "r", + "nativeSrc": "34413:1:0", + "nodeType": "YulIdentifier", + "src": "34413:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "34379:6:0", + "nodeType": "YulIdentifier", + "src": "34379:6:0" + }, + "nativeSrc": "34379:36:0", + "nodeType": "YulFunctionCall", + "src": "34379:36:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "34372:3:0", + "nodeType": "YulIdentifier", + "src": "34372:3:0" + }, + "nativeSrc": "34372:44:0", + "nodeType": "YulFunctionCall", + "src": "34372:44:0" + }, + { + "name": "r", + "nativeSrc": "34418:1:0", + "nodeType": "YulIdentifier", + "src": "34418:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "34360:6:0", + "nodeType": "YulIdentifier", + "src": "34360:6:0" + }, + "nativeSrc": "34360:60:0", + "nodeType": "YulFunctionCall", + "src": "34360:60:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "34352:4:0", + "nodeType": "YulTypedName", + "src": "34352:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "34441:73:0", + "nodeType": "YulAssignment", + "src": "34441:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "34478:19:0", + "nodeType": "YulIdentifier", + "src": "34478:19:0" + }, + { + "name": "y", + "nativeSrc": "34499:1:0", + "nodeType": "YulIdentifier", + "src": "34499:1:0" + }, + { + "name": "r", + "nativeSrc": "34502:1:0", + "nodeType": "YulIdentifier", + "src": "34502:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "34471:6:0", + "nodeType": "YulIdentifier", + "src": "34471:6:0" + }, + "nativeSrc": "34471:33:0", + "nodeType": "YulFunctionCall", + "src": "34471:33:0" + }, + { + "name": "eval", + "nativeSrc": "34506:4:0", + "nodeType": "YulIdentifier", + "src": "34506:4:0" + }, + { + "name": "r", + "nativeSrc": "34512:1:0", + "nodeType": "YulIdentifier", + "src": "34512:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "34464:6:0", + "nodeType": "YulIdentifier", + "src": "34464:6:0" + }, + "nativeSrc": "34464:50:0", + "nodeType": "YulFunctionCall", + "src": "34464:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "34441:19:0", + "nodeType": "YulIdentifier", + "src": "34441:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "34549:304:0", + "nodeType": "YulBlock", + "src": "34549:304:0", + "statements": [ + { + "nativeSrc": "34571:39:0", + "nodeType": "YulVariableDeclaration", + "src": "34571:39:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "34603:6:0", + "nodeType": "YulLiteral", + "src": "34603:6:0", + "type": "", + "value": "0x0784" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "34590:12:0", + "nodeType": "YulIdentifier", + "src": "34590:12:0" + }, + "nativeSrc": "34590:20:0", + "nodeType": "YulFunctionCall", + "src": "34590:20:0" + }, + "variables": [ + { + "name": "perm_z_last", + "nativeSrc": "34575:11:0", + "nodeType": "YulTypedName", + "src": "34575:11:0", + "type": "" + } + ] + }, + { + "nativeSrc": "34631:110:0", + "nodeType": "YulVariableDeclaration", + "src": "34631:110:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "L_LAST_MPTR", + "nativeSrc": "34656:11:0", + "nodeType": "YulIdentifier", + "src": "34656:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "34650:5:0", + "nodeType": "YulIdentifier", + "src": "34650:5:0" + }, + "nativeSrc": "34650:18:0", + "nodeType": "YulFunctionCall", + "src": "34650:18:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "perm_z_last", + "nativeSrc": "34684:11:0", + "nodeType": "YulIdentifier", + "src": "34684:11:0" + }, + { + "name": "perm_z_last", + "nativeSrc": "34697:11:0", + "nodeType": "YulIdentifier", + "src": "34697:11:0" + }, + { + "name": "r", + "nativeSrc": "34710:1:0", + "nodeType": "YulIdentifier", + "src": "34710:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "34677:6:0", + "nodeType": "YulIdentifier", + "src": "34677:6:0" + }, + "nativeSrc": "34677:35:0", + "nodeType": "YulFunctionCall", + "src": "34677:35:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "34718:1:0", + "nodeType": "YulIdentifier", + "src": "34718:1:0" + }, + { + "name": "perm_z_last", + "nativeSrc": "34721:11:0", + "nodeType": "YulIdentifier", + "src": "34721:11:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "34714:3:0", + "nodeType": "YulIdentifier", + "src": "34714:3:0" + }, + "nativeSrc": "34714:19:0", + "nodeType": "YulFunctionCall", + "src": "34714:19:0" + }, + { + "name": "r", + "nativeSrc": "34735:1:0", + "nodeType": "YulIdentifier", + "src": "34735:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "34670:6:0", + "nodeType": "YulIdentifier", + "src": "34670:6:0" + }, + "nativeSrc": "34670:67:0", + "nodeType": "YulFunctionCall", + "src": "34670:67:0" + }, + { + "name": "r", + "nativeSrc": "34739:1:0", + "nodeType": "YulIdentifier", + "src": "34739:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "34643:6:0", + "nodeType": "YulIdentifier", + "src": "34643:6:0" + }, + "nativeSrc": "34643:98:0", + "nodeType": "YulFunctionCall", + "src": "34643:98:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "34635:4:0", + "nodeType": "YulTypedName", + "src": "34635:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "34762:73:0", + "nodeType": "YulAssignment", + "src": "34762:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "34799:19:0", + "nodeType": "YulIdentifier", + "src": "34799:19:0" + }, + { + "name": "y", + "nativeSrc": "34820:1:0", + "nodeType": "YulIdentifier", + "src": "34820:1:0" + }, + { + "name": "r", + "nativeSrc": "34823:1:0", + "nodeType": "YulIdentifier", + "src": "34823:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "34792:6:0", + "nodeType": "YulIdentifier", + "src": "34792:6:0" + }, + "nativeSrc": "34792:33:0", + "nodeType": "YulFunctionCall", + "src": "34792:33:0" + }, + { + "name": "eval", + "nativeSrc": "34827:4:0", + "nodeType": "YulIdentifier", + "src": "34827:4:0" + }, + { + "name": "r", + "nativeSrc": "34833:1:0", + "nodeType": "YulIdentifier", + "src": "34833:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "34785:6:0", + "nodeType": "YulIdentifier", + "src": "34785:6:0" + }, + "nativeSrc": "34785:50:0", + "nodeType": "YulFunctionCall", + "src": "34785:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "34762:19:0", + "nodeType": "YulIdentifier", + "src": "34762:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "34870:235:0", + "nodeType": "YulBlock", + "src": "34870:235:0", + "statements": [ + { + "nativeSrc": "34892:101:0", + "nodeType": "YulVariableDeclaration", + "src": "34892:101:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "L_0_MPTR", + "nativeSrc": "34917:8:0", + "nodeType": "YulIdentifier", + "src": "34917:8:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "34911:5:0", + "nodeType": "YulIdentifier", + "src": "34911:5:0" + }, + "nativeSrc": "34911:15:0", + "nodeType": "YulFunctionCall", + "src": "34911:15:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "34948:6:0", + "nodeType": "YulLiteral", + "src": "34948:6:0", + "type": "", + "value": "0x0784" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "34935:12:0", + "nodeType": "YulIdentifier", + "src": "34935:12:0" + }, + "nativeSrc": "34935:20:0", + "nodeType": "YulFunctionCall", + "src": "34935:20:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "34961:1:0", + "nodeType": "YulIdentifier", + "src": "34961:1:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "34977:6:0", + "nodeType": "YulLiteral", + "src": "34977:6:0", + "type": "", + "value": "0x0764" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "34964:12:0", + "nodeType": "YulIdentifier", + "src": "34964:12:0" + }, + "nativeSrc": "34964:20:0", + "nodeType": "YulFunctionCall", + "src": "34964:20:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "34957:3:0", + "nodeType": "YulIdentifier", + "src": "34957:3:0" + }, + "nativeSrc": "34957:28:0", + "nodeType": "YulFunctionCall", + "src": "34957:28:0" + }, + { + "name": "r", + "nativeSrc": "34987:1:0", + "nodeType": "YulIdentifier", + "src": "34987:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "34928:6:0", + "nodeType": "YulIdentifier", + "src": "34928:6:0" + }, + "nativeSrc": "34928:61:0", + "nodeType": "YulFunctionCall", + "src": "34928:61:0" + }, + { + "name": "r", + "nativeSrc": "34991:1:0", + "nodeType": "YulIdentifier", + "src": "34991:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "34904:6:0", + "nodeType": "YulIdentifier", + "src": "34904:6:0" + }, + "nativeSrc": "34904:89:0", + "nodeType": "YulFunctionCall", + "src": "34904:89:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "34896:4:0", + "nodeType": "YulTypedName", + "src": "34896:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "35014:73:0", + "nodeType": "YulAssignment", + "src": "35014:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "35051:19:0", + "nodeType": "YulIdentifier", + "src": "35051:19:0" + }, + { + "name": "y", + "nativeSrc": "35072:1:0", + "nodeType": "YulIdentifier", + "src": "35072:1:0" + }, + { + "name": "r", + "nativeSrc": "35075:1:0", + "nodeType": "YulIdentifier", + "src": "35075:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "35044:6:0", + "nodeType": "YulIdentifier", + "src": "35044:6:0" + }, + "nativeSrc": "35044:33:0", + "nodeType": "YulFunctionCall", + "src": "35044:33:0" + }, + { + "name": "eval", + "nativeSrc": "35079:4:0", + "nodeType": "YulIdentifier", + "src": "35079:4:0" + }, + { + "name": "r", + "nativeSrc": "35085:1:0", + "nodeType": "YulIdentifier", + "src": "35085:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "35037:6:0", + "nodeType": "YulIdentifier", + "src": "35037:6:0" + }, + "nativeSrc": "35037:50:0", + "nodeType": "YulFunctionCall", + "src": "35037:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "35014:19:0", + "nodeType": "YulIdentifier", + "src": "35014:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "35122:1503:0", + "nodeType": "YulBlock", + "src": "35122:1503:0", + "statements": [ + { + "nativeSrc": "35144:30:0", + "nodeType": "YulVariableDeclaration", + "src": "35144:30:0", + "value": { + "arguments": [ + { + "name": "GAMMA_MPTR", + "nativeSrc": "35163:10:0", + "nodeType": "YulIdentifier", + "src": "35163:10:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "35157:5:0", + "nodeType": "YulIdentifier", + "src": "35157:5:0" + }, + "nativeSrc": "35157:17:0", + "nodeType": "YulFunctionCall", + "src": "35157:17:0" + }, + "variables": [ + { + "name": "gamma", + "nativeSrc": "35148:5:0", + "nodeType": "YulTypedName", + "src": "35148:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "35195:28:0", + "nodeType": "YulVariableDeclaration", + "src": "35195:28:0", + "value": { + "arguments": [ + { + "name": "BETA_MPTR", + "nativeSrc": "35213:9:0", + "nodeType": "YulIdentifier", + "src": "35213:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "35207:5:0", + "nodeType": "YulIdentifier", + "src": "35207:5:0" + }, + "nativeSrc": "35207:16:0", + "nodeType": "YulFunctionCall", + "src": "35207:16:0" + }, + "variables": [ + { + "name": "beta", + "nativeSrc": "35199:4:0", + "nodeType": "YulTypedName", + "src": "35199:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "35244:31:0", + "nodeType": "YulVariableDeclaration", + "src": "35244:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "35268:6:0", + "nodeType": "YulLiteral", + "src": "35268:6:0", + "type": "", + "value": "0x0744" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "35255:12:0", + "nodeType": "YulIdentifier", + "src": "35255:12:0" + }, + "nativeSrc": "35255:20:0", + "nodeType": "YulFunctionCall", + "src": "35255:20:0" + }, + "variables": [ + { + "name": "lhs", + "nativeSrc": "35248:3:0", + "nodeType": "YulTypedName", + "src": "35248:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "35296:31:0", + "nodeType": "YulVariableDeclaration", + "src": "35296:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "35320:6:0", + "nodeType": "YulLiteral", + "src": "35320:6:0", + "type": "", + "value": "0x0724" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "35307:12:0", + "nodeType": "YulIdentifier", + "src": "35307:12:0" + }, + "nativeSrc": "35307:20:0", + "nodeType": "YulFunctionCall", + "src": "35307:20:0" + }, + "variables": [ + { + "name": "rhs", + "nativeSrc": "35300:3:0", + "nodeType": "YulTypedName", + "src": "35300:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "35348:111:0", + "nodeType": "YulAssignment", + "src": "35348:111:0", + "value": { + "arguments": [ + { + "name": "lhs", + "nativeSrc": "35362:3:0", + "nodeType": "YulIdentifier", + "src": "35362:3:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "35394:6:0", + "nodeType": "YulLiteral", + "src": "35394:6:0", + "type": "", + "value": "0x0464" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "35381:12:0", + "nodeType": "YulIdentifier", + "src": "35381:12:0" + }, + "nativeSrc": "35381:20:0", + "nodeType": "YulFunctionCall", + "src": "35381:20:0" + }, + { + "arguments": [ + { + "name": "beta", + "nativeSrc": "35410:4:0", + "nodeType": "YulIdentifier", + "src": "35410:4:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "35429:6:0", + "nodeType": "YulLiteral", + "src": "35429:6:0", + "type": "", + "value": "0x0684" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "35416:12:0", + "nodeType": "YulIdentifier", + "src": "35416:12:0" + }, + "nativeSrc": "35416:20:0", + "nodeType": "YulFunctionCall", + "src": "35416:20:0" + }, + { + "name": "r", + "nativeSrc": "35438:1:0", + "nodeType": "YulIdentifier", + "src": "35438:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "35403:6:0", + "nodeType": "YulIdentifier", + "src": "35403:6:0" + }, + "nativeSrc": "35403:37:0", + "nodeType": "YulFunctionCall", + "src": "35403:37:0" + }, + { + "name": "r", + "nativeSrc": "35442:1:0", + "nodeType": "YulIdentifier", + "src": "35442:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "35374:6:0", + "nodeType": "YulIdentifier", + "src": "35374:6:0" + }, + "nativeSrc": "35374:70:0", + "nodeType": "YulFunctionCall", + "src": "35374:70:0" + }, + { + "name": "gamma", + "nativeSrc": "35446:5:0", + "nodeType": "YulIdentifier", + "src": "35446:5:0" + }, + { + "name": "r", + "nativeSrc": "35453:1:0", + "nodeType": "YulIdentifier", + "src": "35453:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "35367:6:0", + "nodeType": "YulIdentifier", + "src": "35367:6:0" + }, + "nativeSrc": "35367:88:0", + "nodeType": "YulFunctionCall", + "src": "35367:88:0" + }, + { + "name": "r", + "nativeSrc": "35457:1:0", + "nodeType": "YulIdentifier", + "src": "35457:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "35355:6:0", + "nodeType": "YulIdentifier", + "src": "35355:6:0" + }, + "nativeSrc": "35355:104:0", + "nodeType": "YulFunctionCall", + "src": "35355:104:0" + }, + "variableNames": [ + { + "name": "lhs", + "nativeSrc": "35348:3:0", + "nodeType": "YulIdentifier", + "src": "35348:3:0" + } + ] + }, + { + "nativeSrc": "35480:111:0", + "nodeType": "YulAssignment", + "src": "35480:111:0", + "value": { + "arguments": [ + { + "name": "lhs", + "nativeSrc": "35494:3:0", + "nodeType": "YulIdentifier", + "src": "35494:3:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "35526:6:0", + "nodeType": "YulLiteral", + "src": "35526:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "35513:12:0", + "nodeType": "YulIdentifier", + "src": "35513:12:0" + }, + "nativeSrc": "35513:20:0", + "nodeType": "YulFunctionCall", + "src": "35513:20:0" + }, + { + "arguments": [ + { + "name": "beta", + "nativeSrc": "35542:4:0", + "nodeType": "YulIdentifier", + "src": "35542:4:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "35561:6:0", + "nodeType": "YulLiteral", + "src": "35561:6:0", + "type": "", + "value": "0x06a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "35548:12:0", + "nodeType": "YulIdentifier", + "src": "35548:12:0" + }, + "nativeSrc": "35548:20:0", + "nodeType": "YulFunctionCall", + "src": "35548:20:0" + }, + { + "name": "r", + "nativeSrc": "35570:1:0", + "nodeType": "YulIdentifier", + "src": "35570:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "35535:6:0", + "nodeType": "YulIdentifier", + "src": "35535:6:0" + }, + "nativeSrc": "35535:37:0", + "nodeType": "YulFunctionCall", + "src": "35535:37:0" + }, + { + "name": "r", + "nativeSrc": "35574:1:0", + "nodeType": "YulIdentifier", + "src": "35574:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "35506:6:0", + "nodeType": "YulIdentifier", + "src": "35506:6:0" + }, + "nativeSrc": "35506:70:0", + "nodeType": "YulFunctionCall", + "src": "35506:70:0" + }, + { + "name": "gamma", + "nativeSrc": "35578:5:0", + "nodeType": "YulIdentifier", + "src": "35578:5:0" + }, + { + "name": "r", + "nativeSrc": "35585:1:0", + "nodeType": "YulIdentifier", + "src": "35585:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "35499:6:0", + "nodeType": "YulIdentifier", + "src": "35499:6:0" + }, + "nativeSrc": "35499:88:0", + "nodeType": "YulFunctionCall", + "src": "35499:88:0" + }, + { + "name": "r", + "nativeSrc": "35589:1:0", + "nodeType": "YulIdentifier", + "src": "35589:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "35487:6:0", + "nodeType": "YulIdentifier", + "src": "35487:6:0" + }, + "nativeSrc": "35487:104:0", + "nodeType": "YulFunctionCall", + "src": "35487:104:0" + }, + "variableNames": [ + { + "name": "lhs", + "nativeSrc": "35480:3:0", + "nodeType": "YulIdentifier", + "src": "35480:3:0" + } + ] + }, + { + "nativeSrc": "35612:111:0", + "nodeType": "YulAssignment", + "src": "35612:111:0", + "value": { + "arguments": [ + { + "name": "lhs", + "nativeSrc": "35626:3:0", + "nodeType": "YulIdentifier", + "src": "35626:3:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "35658:6:0", + "nodeType": "YulLiteral", + "src": "35658:6:0", + "type": "", + "value": "0x04a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "35645:12:0", + "nodeType": "YulIdentifier", + "src": "35645:12:0" + }, + "nativeSrc": "35645:20:0", + "nodeType": "YulFunctionCall", + "src": "35645:20:0" + }, + { + "arguments": [ + { + "name": "beta", + "nativeSrc": "35674:4:0", + "nodeType": "YulIdentifier", + "src": "35674:4:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "35693:6:0", + "nodeType": "YulLiteral", + "src": "35693:6:0", + "type": "", + "value": "0x06c4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "35680:12:0", + "nodeType": "YulIdentifier", + "src": "35680:12:0" + }, + "nativeSrc": "35680:20:0", + "nodeType": "YulFunctionCall", + "src": "35680:20:0" + }, + { + "name": "r", + "nativeSrc": "35702:1:0", + "nodeType": "YulIdentifier", + "src": "35702:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "35667:6:0", + "nodeType": "YulIdentifier", + "src": "35667:6:0" + }, + "nativeSrc": "35667:37:0", + "nodeType": "YulFunctionCall", + "src": "35667:37:0" + }, + { + "name": "r", + "nativeSrc": "35706:1:0", + "nodeType": "YulIdentifier", + "src": "35706:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "35638:6:0", + "nodeType": "YulIdentifier", + "src": "35638:6:0" + }, + "nativeSrc": "35638:70:0", + "nodeType": "YulFunctionCall", + "src": "35638:70:0" + }, + { + "name": "gamma", + "nativeSrc": "35710:5:0", + "nodeType": "YulIdentifier", + "src": "35710:5:0" + }, + { + "name": "r", + "nativeSrc": "35717:1:0", + "nodeType": "YulIdentifier", + "src": "35717:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "35631:6:0", + "nodeType": "YulIdentifier", + "src": "35631:6:0" + }, + "nativeSrc": "35631:88:0", + "nodeType": "YulFunctionCall", + "src": "35631:88:0" + }, + { + "name": "r", + "nativeSrc": "35721:1:0", + "nodeType": "YulIdentifier", + "src": "35721:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "35619:6:0", + "nodeType": "YulIdentifier", + "src": "35619:6:0" + }, + "nativeSrc": "35619:104:0", + "nodeType": "YulFunctionCall", + "src": "35619:104:0" + }, + "variableNames": [ + { + "name": "lhs", + "nativeSrc": "35612:3:0", + "nodeType": "YulIdentifier", + "src": "35612:3:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "35751:4:0", + "nodeType": "YulLiteral", + "src": "35751:4:0", + "type": "", + "value": "0x00" + }, + { + "arguments": [ + { + "name": "beta", + "nativeSrc": "35764:4:0", + "nodeType": "YulIdentifier", + "src": "35764:4:0" + }, + { + "arguments": [ + { + "name": "X_MPTR", + "nativeSrc": "35776:6:0", + "nodeType": "YulIdentifier", + "src": "35776:6:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "35770:5:0", + "nodeType": "YulIdentifier", + "src": "35770:5:0" + }, + "nativeSrc": "35770:13:0", + "nodeType": "YulFunctionCall", + "src": "35770:13:0" + }, + { + "name": "r", + "nativeSrc": "35785:1:0", + "nodeType": "YulIdentifier", + "src": "35785:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "35757:6:0", + "nodeType": "YulIdentifier", + "src": "35757:6:0" + }, + "nativeSrc": "35757:30:0", + "nodeType": "YulFunctionCall", + "src": "35757:30:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "35744:6:0", + "nodeType": "YulIdentifier", + "src": "35744:6:0" + }, + "nativeSrc": "35744:44:0", + "nodeType": "YulFunctionCall", + "src": "35744:44:0" + }, + "nativeSrc": "35744:44:0", + "nodeType": "YulExpressionStatement", + "src": "35744:44:0" + }, + { + "nativeSrc": "35809:85:0", + "nodeType": "YulAssignment", + "src": "35809:85:0", + "value": { + "arguments": [ + { + "name": "rhs", + "nativeSrc": "35823:3:0", + "nodeType": "YulIdentifier", + "src": "35823:3:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "35855:6:0", + "nodeType": "YulLiteral", + "src": "35855:6:0", + "type": "", + "value": "0x0464" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "35842:12:0", + "nodeType": "YulIdentifier", + "src": "35842:12:0" + }, + "nativeSrc": "35842:20:0", + "nodeType": "YulFunctionCall", + "src": "35842:20:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "35870:4:0", + "nodeType": "YulLiteral", + "src": "35870:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "35864:5:0", + "nodeType": "YulIdentifier", + "src": "35864:5:0" + }, + "nativeSrc": "35864:11:0", + "nodeType": "YulFunctionCall", + "src": "35864:11:0" + }, + { + "name": "r", + "nativeSrc": "35877:1:0", + "nodeType": "YulIdentifier", + "src": "35877:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "35835:6:0", + "nodeType": "YulIdentifier", + "src": "35835:6:0" + }, + "nativeSrc": "35835:44:0", + "nodeType": "YulFunctionCall", + "src": "35835:44:0" + }, + { + "name": "gamma", + "nativeSrc": "35881:5:0", + "nodeType": "YulIdentifier", + "src": "35881:5:0" + }, + { + "name": "r", + "nativeSrc": "35888:1:0", + "nodeType": "YulIdentifier", + "src": "35888:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "35828:6:0", + "nodeType": "YulIdentifier", + "src": "35828:6:0" + }, + "nativeSrc": "35828:62:0", + "nodeType": "YulFunctionCall", + "src": "35828:62:0" + }, + { + "name": "r", + "nativeSrc": "35892:1:0", + "nodeType": "YulIdentifier", + "src": "35892:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "35816:6:0", + "nodeType": "YulIdentifier", + "src": "35816:6:0" + }, + "nativeSrc": "35816:78:0", + "nodeType": "YulFunctionCall", + "src": "35816:78:0" + }, + "variableNames": [ + { + "name": "rhs", + "nativeSrc": "35809:3:0", + "nodeType": "YulIdentifier", + "src": "35809:3:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "35922:4:0", + "nodeType": "YulLiteral", + "src": "35922:4:0", + "type": "", + "value": "0x00" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "35941:4:0", + "nodeType": "YulLiteral", + "src": "35941:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "35935:5:0", + "nodeType": "YulIdentifier", + "src": "35935:5:0" + }, + "nativeSrc": "35935:11:0", + "nodeType": "YulFunctionCall", + "src": "35935:11:0" + }, + { + "name": "delta", + "nativeSrc": "35948:5:0", + "nodeType": "YulIdentifier", + "src": "35948:5:0" + }, + { + "name": "r", + "nativeSrc": "35955:1:0", + "nodeType": "YulIdentifier", + "src": "35955:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "35928:6:0", + "nodeType": "YulIdentifier", + "src": "35928:6:0" + }, + "nativeSrc": "35928:29:0", + "nodeType": "YulFunctionCall", + "src": "35928:29:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "35915:6:0", + "nodeType": "YulIdentifier", + "src": "35915:6:0" + }, + "nativeSrc": "35915:43:0", + "nodeType": "YulFunctionCall", + "src": "35915:43:0" + }, + "nativeSrc": "35915:43:0", + "nodeType": "YulExpressionStatement", + "src": "35915:43:0" + }, + { + "nativeSrc": "35979:85:0", + "nodeType": "YulAssignment", + "src": "35979:85:0", + "value": { + "arguments": [ + { + "name": "rhs", + "nativeSrc": "35993:3:0", + "nodeType": "YulIdentifier", + "src": "35993:3:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "36025:6:0", + "nodeType": "YulLiteral", + "src": "36025:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "36012:12:0", + "nodeType": "YulIdentifier", + "src": "36012:12:0" + }, + "nativeSrc": "36012:20:0", + "nodeType": "YulFunctionCall", + "src": "36012:20:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "36040:4:0", + "nodeType": "YulLiteral", + "src": "36040:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "36034:5:0", + "nodeType": "YulIdentifier", + "src": "36034:5:0" + }, + "nativeSrc": "36034:11:0", + "nodeType": "YulFunctionCall", + "src": "36034:11:0" + }, + { + "name": "r", + "nativeSrc": "36047:1:0", + "nodeType": "YulIdentifier", + "src": "36047:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "36005:6:0", + "nodeType": "YulIdentifier", + "src": "36005:6:0" + }, + "nativeSrc": "36005:44:0", + "nodeType": "YulFunctionCall", + "src": "36005:44:0" + }, + { + "name": "gamma", + "nativeSrc": "36051:5:0", + "nodeType": "YulIdentifier", + "src": "36051:5:0" + }, + { + "name": "r", + "nativeSrc": "36058:1:0", + "nodeType": "YulIdentifier", + "src": "36058:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "35998:6:0", + "nodeType": "YulIdentifier", + "src": "35998:6:0" + }, + "nativeSrc": "35998:62:0", + "nodeType": "YulFunctionCall", + "src": "35998:62:0" + }, + { + "name": "r", + "nativeSrc": "36062:1:0", + "nodeType": "YulIdentifier", + "src": "36062:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "35986:6:0", + "nodeType": "YulIdentifier", + "src": "35986:6:0" + }, + "nativeSrc": "35986:78:0", + "nodeType": "YulFunctionCall", + "src": "35986:78:0" + }, + "variableNames": [ + { + "name": "rhs", + "nativeSrc": "35979:3:0", + "nodeType": "YulIdentifier", + "src": "35979:3:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "36092:4:0", + "nodeType": "YulLiteral", + "src": "36092:4:0", + "type": "", + "value": "0x00" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "36111:4:0", + "nodeType": "YulLiteral", + "src": "36111:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "36105:5:0", + "nodeType": "YulIdentifier", + "src": "36105:5:0" + }, + "nativeSrc": "36105:11:0", + "nodeType": "YulFunctionCall", + "src": "36105:11:0" + }, + { + "name": "delta", + "nativeSrc": "36118:5:0", + "nodeType": "YulIdentifier", + "src": "36118:5:0" + }, + { + "name": "r", + "nativeSrc": "36125:1:0", + "nodeType": "YulIdentifier", + "src": "36125:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "36098:6:0", + "nodeType": "YulIdentifier", + "src": "36098:6:0" + }, + "nativeSrc": "36098:29:0", + "nodeType": "YulFunctionCall", + "src": "36098:29:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "36085:6:0", + "nodeType": "YulIdentifier", + "src": "36085:6:0" + }, + "nativeSrc": "36085:43:0", + "nodeType": "YulFunctionCall", + "src": "36085:43:0" + }, + "nativeSrc": "36085:43:0", + "nodeType": "YulExpressionStatement", + "src": "36085:43:0" + }, + { + "nativeSrc": "36149:85:0", + "nodeType": "YulAssignment", + "src": "36149:85:0", + "value": { + "arguments": [ + { + "name": "rhs", + "nativeSrc": "36163:3:0", + "nodeType": "YulIdentifier", + "src": "36163:3:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "36195:6:0", + "nodeType": "YulLiteral", + "src": "36195:6:0", + "type": "", + "value": "0x04a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "36182:12:0", + "nodeType": "YulIdentifier", + "src": "36182:12:0" + }, + "nativeSrc": "36182:20:0", + "nodeType": "YulFunctionCall", + "src": "36182:20:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "36210:4:0", + "nodeType": "YulLiteral", + "src": "36210:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "36204:5:0", + "nodeType": "YulIdentifier", + "src": "36204:5:0" + }, + "nativeSrc": "36204:11:0", + "nodeType": "YulFunctionCall", + "src": "36204:11:0" + }, + { + "name": "r", + "nativeSrc": "36217:1:0", + "nodeType": "YulIdentifier", + "src": "36217:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "36175:6:0", + "nodeType": "YulIdentifier", + "src": "36175:6:0" + }, + "nativeSrc": "36175:44:0", + "nodeType": "YulFunctionCall", + "src": "36175:44:0" + }, + { + "name": "gamma", + "nativeSrc": "36221:5:0", + "nodeType": "YulIdentifier", + "src": "36221:5:0" + }, + { + "name": "r", + "nativeSrc": "36228:1:0", + "nodeType": "YulIdentifier", + "src": "36228:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "36168:6:0", + "nodeType": "YulIdentifier", + "src": "36168:6:0" + }, + "nativeSrc": "36168:62:0", + "nodeType": "YulFunctionCall", + "src": "36168:62:0" + }, + { + "name": "r", + "nativeSrc": "36232:1:0", + "nodeType": "YulIdentifier", + "src": "36232:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "36156:6:0", + "nodeType": "YulIdentifier", + "src": "36156:6:0" + }, + "nativeSrc": "36156:78:0", + "nodeType": "YulFunctionCall", + "src": "36156:78:0" + }, + "variableNames": [ + { + "name": "rhs", + "nativeSrc": "36149:3:0", + "nodeType": "YulIdentifier", + "src": "36149:3:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "36262:4:0", + "nodeType": "YulLiteral", + "src": "36262:4:0", + "type": "", + "value": "0x00" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "36281:4:0", + "nodeType": "YulLiteral", + "src": "36281:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "36275:5:0", + "nodeType": "YulIdentifier", + "src": "36275:5:0" + }, + "nativeSrc": "36275:11:0", + "nodeType": "YulFunctionCall", + "src": "36275:11:0" + }, + { + "name": "delta", + "nativeSrc": "36288:5:0", + "nodeType": "YulIdentifier", + "src": "36288:5:0" + }, + { + "name": "r", + "nativeSrc": "36295:1:0", + "nodeType": "YulIdentifier", + "src": "36295:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "36268:6:0", + "nodeType": "YulIdentifier", + "src": "36268:6:0" + }, + "nativeSrc": "36268:29:0", + "nodeType": "YulFunctionCall", + "src": "36268:29:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "36255:6:0", + "nodeType": "YulIdentifier", + "src": "36255:6:0" + }, + "nativeSrc": "36255:43:0", + "nodeType": "YulFunctionCall", + "src": "36255:43:0" + }, + "nativeSrc": "36255:43:0", + "nodeType": "YulExpressionStatement", + "src": "36255:43:0" + }, + { + "nativeSrc": "36319:49:0", + "nodeType": "YulVariableDeclaration", + "src": "36319:49:0", + "value": { + "arguments": [ + { + "name": "lhs", + "nativeSrc": "36348:3:0", + "nodeType": "YulIdentifier", + "src": "36348:3:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "36357:1:0", + "nodeType": "YulIdentifier", + "src": "36357:1:0" + }, + { + "name": "rhs", + "nativeSrc": "36360:3:0", + "nodeType": "YulIdentifier", + "src": "36360:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "36353:3:0", + "nodeType": "YulIdentifier", + "src": "36353:3:0" + }, + "nativeSrc": "36353:11:0", + "nodeType": "YulFunctionCall", + "src": "36353:11:0" + }, + { + "name": "r", + "nativeSrc": "36366:1:0", + "nodeType": "YulIdentifier", + "src": "36366:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "36341:6:0", + "nodeType": "YulIdentifier", + "src": "36341:6:0" + }, + "nativeSrc": "36341:27:0", + "nodeType": "YulFunctionCall", + "src": "36341:27:0" + }, + "variables": [ + { + "name": "left_sub_right", + "nativeSrc": "36323:14:0", + "nodeType": "YulTypedName", + "src": "36323:14:0", + "type": "" + } + ] + }, + { + "nativeSrc": "36389:124:0", + "nodeType": "YulVariableDeclaration", + "src": "36389:124:0", + "value": { + "arguments": [ + { + "name": "left_sub_right", + "nativeSrc": "36408:14:0", + "nodeType": "YulIdentifier", + "src": "36408:14:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "36428:1:0", + "nodeType": "YulIdentifier", + "src": "36428:1:0" + }, + { + "arguments": [ + { + "name": "left_sub_right", + "nativeSrc": "36438:14:0", + "nodeType": "YulIdentifier", + "src": "36438:14:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "L_LAST_MPTR", + "nativeSrc": "36467:11:0", + "nodeType": "YulIdentifier", + "src": "36467:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "36461:5:0", + "nodeType": "YulIdentifier", + "src": "36461:5:0" + }, + "nativeSrc": "36461:18:0", + "nodeType": "YulFunctionCall", + "src": "36461:18:0" + }, + { + "arguments": [ + { + "name": "L_BLIND_MPTR", + "nativeSrc": "36487:12:0", + "nodeType": "YulIdentifier", + "src": "36487:12:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "36481:5:0", + "nodeType": "YulIdentifier", + "src": "36481:5:0" + }, + "nativeSrc": "36481:19:0", + "nodeType": "YulFunctionCall", + "src": "36481:19:0" + }, + { + "name": "r", + "nativeSrc": "36502:1:0", + "nodeType": "YulIdentifier", + "src": "36502:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "36454:6:0", + "nodeType": "YulIdentifier", + "src": "36454:6:0" + }, + "nativeSrc": "36454:50:0", + "nodeType": "YulFunctionCall", + "src": "36454:50:0" + }, + { + "name": "r", + "nativeSrc": "36506:1:0", + "nodeType": "YulIdentifier", + "src": "36506:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "36431:6:0", + "nodeType": "YulIdentifier", + "src": "36431:6:0" + }, + "nativeSrc": "36431:77:0", + "nodeType": "YulFunctionCall", + "src": "36431:77:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "36424:3:0", + "nodeType": "YulIdentifier", + "src": "36424:3:0" + }, + "nativeSrc": "36424:85:0", + "nodeType": "YulFunctionCall", + "src": "36424:85:0" + }, + { + "name": "r", + "nativeSrc": "36511:1:0", + "nodeType": "YulIdentifier", + "src": "36511:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "36401:6:0", + "nodeType": "YulIdentifier", + "src": "36401:6:0" + }, + "nativeSrc": "36401:112:0", + "nodeType": "YulFunctionCall", + "src": "36401:112:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "36393:4:0", + "nodeType": "YulTypedName", + "src": "36393:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "36534:73:0", + "nodeType": "YulAssignment", + "src": "36534:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "36571:19:0", + "nodeType": "YulIdentifier", + "src": "36571:19:0" + }, + { + "name": "y", + "nativeSrc": "36592:1:0", + "nodeType": "YulIdentifier", + "src": "36592:1:0" + }, + { + "name": "r", + "nativeSrc": "36595:1:0", + "nodeType": "YulIdentifier", + "src": "36595:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "36564:6:0", + "nodeType": "YulIdentifier", + "src": "36564:6:0" + }, + "nativeSrc": "36564:33:0", + "nodeType": "YulFunctionCall", + "src": "36564:33:0" + }, + { + "name": "eval", + "nativeSrc": "36599:4:0", + "nodeType": "YulIdentifier", + "src": "36599:4:0" + }, + { + "name": "r", + "nativeSrc": "36605:1:0", + "nodeType": "YulIdentifier", + "src": "36605:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "36557:6:0", + "nodeType": "YulIdentifier", + "src": "36557:6:0" + }, + "nativeSrc": "36557:50:0", + "nodeType": "YulFunctionCall", + "src": "36557:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "36534:19:0", + "nodeType": "YulIdentifier", + "src": "36534:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "36642:1082:0", + "nodeType": "YulBlock", + "src": "36642:1082:0", + "statements": [ + { + "nativeSrc": "36664:30:0", + "nodeType": "YulVariableDeclaration", + "src": "36664:30:0", + "value": { + "arguments": [ + { + "name": "GAMMA_MPTR", + "nativeSrc": "36683:10:0", + "nodeType": "YulIdentifier", + "src": "36683:10:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "36677:5:0", + "nodeType": "YulIdentifier", + "src": "36677:5:0" + }, + "nativeSrc": "36677:17:0", + "nodeType": "YulFunctionCall", + "src": "36677:17:0" + }, + "variables": [ + { + "name": "gamma", + "nativeSrc": "36668:5:0", + "nodeType": "YulTypedName", + "src": "36668:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "36715:28:0", + "nodeType": "YulVariableDeclaration", + "src": "36715:28:0", + "value": { + "arguments": [ + { + "name": "BETA_MPTR", + "nativeSrc": "36733:9:0", + "nodeType": "YulIdentifier", + "src": "36733:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "36727:5:0", + "nodeType": "YulIdentifier", + "src": "36727:5:0" + }, + "nativeSrc": "36727:16:0", + "nodeType": "YulFunctionCall", + "src": "36727:16:0" + }, + "variables": [ + { + "name": "beta", + "nativeSrc": "36719:4:0", + "nodeType": "YulTypedName", + "src": "36719:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "36764:31:0", + "nodeType": "YulVariableDeclaration", + "src": "36764:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "36788:6:0", + "nodeType": "YulLiteral", + "src": "36788:6:0", + "type": "", + "value": "0x07a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "36775:12:0", + "nodeType": "YulIdentifier", + "src": "36775:12:0" + }, + "nativeSrc": "36775:20:0", + "nodeType": "YulFunctionCall", + "src": "36775:20:0" + }, + "variables": [ + { + "name": "lhs", + "nativeSrc": "36768:3:0", + "nodeType": "YulTypedName", + "src": "36768:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "36816:31:0", + "nodeType": "YulVariableDeclaration", + "src": "36816:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "36840:6:0", + "nodeType": "YulLiteral", + "src": "36840:6:0", + "type": "", + "value": "0x0784" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "36827:12:0", + "nodeType": "YulIdentifier", + "src": "36827:12:0" + }, + "nativeSrc": "36827:20:0", + "nodeType": "YulFunctionCall", + "src": "36827:20:0" + }, + "variables": [ + { + "name": "rhs", + "nativeSrc": "36820:3:0", + "nodeType": "YulTypedName", + "src": "36820:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "36868:111:0", + "nodeType": "YulAssignment", + "src": "36868:111:0", + "value": { + "arguments": [ + { + "name": "lhs", + "nativeSrc": "36882:3:0", + "nodeType": "YulIdentifier", + "src": "36882:3:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "36914:6:0", + "nodeType": "YulLiteral", + "src": "36914:6:0", + "type": "", + "value": "0x04e4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "36901:12:0", + "nodeType": "YulIdentifier", + "src": "36901:12:0" + }, + "nativeSrc": "36901:20:0", + "nodeType": "YulFunctionCall", + "src": "36901:20:0" + }, + { + "arguments": [ + { + "name": "beta", + "nativeSrc": "36930:4:0", + "nodeType": "YulIdentifier", + "src": "36930:4:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "36949:6:0", + "nodeType": "YulLiteral", + "src": "36949:6:0", + "type": "", + "value": "0x06e4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "36936:12:0", + "nodeType": "YulIdentifier", + "src": "36936:12:0" + }, + "nativeSrc": "36936:20:0", + "nodeType": "YulFunctionCall", + "src": "36936:20:0" + }, + { + "name": "r", + "nativeSrc": "36958:1:0", + "nodeType": "YulIdentifier", + "src": "36958:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "36923:6:0", + "nodeType": "YulIdentifier", + "src": "36923:6:0" + }, + "nativeSrc": "36923:37:0", + "nodeType": "YulFunctionCall", + "src": "36923:37:0" + }, + { + "name": "r", + "nativeSrc": "36962:1:0", + "nodeType": "YulIdentifier", + "src": "36962:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "36894:6:0", + "nodeType": "YulIdentifier", + "src": "36894:6:0" + }, + "nativeSrc": "36894:70:0", + "nodeType": "YulFunctionCall", + "src": "36894:70:0" + }, + { + "name": "gamma", + "nativeSrc": "36966:5:0", + "nodeType": "YulIdentifier", + "src": "36966:5:0" + }, + { + "name": "r", + "nativeSrc": "36973:1:0", + "nodeType": "YulIdentifier", + "src": "36973:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "36887:6:0", + "nodeType": "YulIdentifier", + "src": "36887:6:0" + }, + "nativeSrc": "36887:88:0", + "nodeType": "YulFunctionCall", + "src": "36887:88:0" + }, + { + "name": "r", + "nativeSrc": "36977:1:0", + "nodeType": "YulIdentifier", + "src": "36977:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "36875:6:0", + "nodeType": "YulIdentifier", + "src": "36875:6:0" + }, + "nativeSrc": "36875:104:0", + "nodeType": "YulFunctionCall", + "src": "36875:104:0" + }, + "variableNames": [ + { + "name": "lhs", + "nativeSrc": "36868:3:0", + "nodeType": "YulIdentifier", + "src": "36868:3:0" + } + ] + }, + { + "nativeSrc": "37000:116:0", + "nodeType": "YulAssignment", + "src": "37000:116:0", + "value": { + "arguments": [ + { + "name": "lhs", + "nativeSrc": "37014:3:0", + "nodeType": "YulIdentifier", + "src": "37014:3:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "arguments": [ + { + "name": "INSTANCE_EVAL_MPTR", + "nativeSrc": "37039:18:0", + "nodeType": "YulIdentifier", + "src": "37039:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "37033:5:0", + "nodeType": "YulIdentifier", + "src": "37033:5:0" + }, + "nativeSrc": "37033:25:0", + "nodeType": "YulFunctionCall", + "src": "37033:25:0" + }, + { + "arguments": [ + { + "name": "beta", + "nativeSrc": "37067:4:0", + "nodeType": "YulIdentifier", + "src": "37067:4:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "37086:6:0", + "nodeType": "YulLiteral", + "src": "37086:6:0", + "type": "", + "value": "0x0704" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "37073:12:0", + "nodeType": "YulIdentifier", + "src": "37073:12:0" + }, + "nativeSrc": "37073:20:0", + "nodeType": "YulFunctionCall", + "src": "37073:20:0" + }, + { + "name": "r", + "nativeSrc": "37095:1:0", + "nodeType": "YulIdentifier", + "src": "37095:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "37060:6:0", + "nodeType": "YulIdentifier", + "src": "37060:6:0" + }, + "nativeSrc": "37060:37:0", + "nodeType": "YulFunctionCall", + "src": "37060:37:0" + }, + { + "name": "r", + "nativeSrc": "37099:1:0", + "nodeType": "YulIdentifier", + "src": "37099:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "37026:6:0", + "nodeType": "YulIdentifier", + "src": "37026:6:0" + }, + "nativeSrc": "37026:75:0", + "nodeType": "YulFunctionCall", + "src": "37026:75:0" + }, + { + "name": "gamma", + "nativeSrc": "37103:5:0", + "nodeType": "YulIdentifier", + "src": "37103:5:0" + }, + { + "name": "r", + "nativeSrc": "37110:1:0", + "nodeType": "YulIdentifier", + "src": "37110:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "37019:6:0", + "nodeType": "YulIdentifier", + "src": "37019:6:0" + }, + "nativeSrc": "37019:93:0", + "nodeType": "YulFunctionCall", + "src": "37019:93:0" + }, + { + "name": "r", + "nativeSrc": "37114:1:0", + "nodeType": "YulIdentifier", + "src": "37114:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "37007:6:0", + "nodeType": "YulIdentifier", + "src": "37007:6:0" + }, + "nativeSrc": "37007:109:0", + "nodeType": "YulFunctionCall", + "src": "37007:109:0" + }, + "variableNames": [ + { + "name": "lhs", + "nativeSrc": "37000:3:0", + "nodeType": "YulIdentifier", + "src": "37000:3:0" + } + ] + }, + { + "nativeSrc": "37137:85:0", + "nodeType": "YulAssignment", + "src": "37137:85:0", + "value": { + "arguments": [ + { + "name": "rhs", + "nativeSrc": "37151:3:0", + "nodeType": "YulIdentifier", + "src": "37151:3:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "37183:6:0", + "nodeType": "YulLiteral", + "src": "37183:6:0", + "type": "", + "value": "0x04e4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "37170:12:0", + "nodeType": "YulIdentifier", + "src": "37170:12:0" + }, + "nativeSrc": "37170:20:0", + "nodeType": "YulFunctionCall", + "src": "37170:20:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "37198:4:0", + "nodeType": "YulLiteral", + "src": "37198:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "37192:5:0", + "nodeType": "YulIdentifier", + "src": "37192:5:0" + }, + "nativeSrc": "37192:11:0", + "nodeType": "YulFunctionCall", + "src": "37192:11:0" + }, + { + "name": "r", + "nativeSrc": "37205:1:0", + "nodeType": "YulIdentifier", + "src": "37205:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "37163:6:0", + "nodeType": "YulIdentifier", + "src": "37163:6:0" + }, + "nativeSrc": "37163:44:0", + "nodeType": "YulFunctionCall", + "src": "37163:44:0" + }, + { + "name": "gamma", + "nativeSrc": "37209:5:0", + "nodeType": "YulIdentifier", + "src": "37209:5:0" + }, + { + "name": "r", + "nativeSrc": "37216:1:0", + "nodeType": "YulIdentifier", + "src": "37216:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "37156:6:0", + "nodeType": "YulIdentifier", + "src": "37156:6:0" + }, + "nativeSrc": "37156:62:0", + "nodeType": "YulFunctionCall", + "src": "37156:62:0" + }, + { + "name": "r", + "nativeSrc": "37220:1:0", + "nodeType": "YulIdentifier", + "src": "37220:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "37144:6:0", + "nodeType": "YulIdentifier", + "src": "37144:6:0" + }, + "nativeSrc": "37144:78:0", + "nodeType": "YulFunctionCall", + "src": "37144:78:0" + }, + "variableNames": [ + { + "name": "rhs", + "nativeSrc": "37137:3:0", + "nodeType": "YulIdentifier", + "src": "37137:3:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "37250:4:0", + "nodeType": "YulLiteral", + "src": "37250:4:0", + "type": "", + "value": "0x00" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "37269:4:0", + "nodeType": "YulLiteral", + "src": "37269:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "37263:5:0", + "nodeType": "YulIdentifier", + "src": "37263:5:0" + }, + "nativeSrc": "37263:11:0", + "nodeType": "YulFunctionCall", + "src": "37263:11:0" + }, + { + "name": "delta", + "nativeSrc": "37276:5:0", + "nodeType": "YulIdentifier", + "src": "37276:5:0" + }, + { + "name": "r", + "nativeSrc": "37283:1:0", + "nodeType": "YulIdentifier", + "src": "37283:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "37256:6:0", + "nodeType": "YulIdentifier", + "src": "37256:6:0" + }, + "nativeSrc": "37256:29:0", + "nodeType": "YulFunctionCall", + "src": "37256:29:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "37243:6:0", + "nodeType": "YulIdentifier", + "src": "37243:6:0" + }, + "nativeSrc": "37243:43:0", + "nodeType": "YulFunctionCall", + "src": "37243:43:0" + }, + "nativeSrc": "37243:43:0", + "nodeType": "YulExpressionStatement", + "src": "37243:43:0" + }, + { + "nativeSrc": "37307:90:0", + "nodeType": "YulAssignment", + "src": "37307:90:0", + "value": { + "arguments": [ + { + "name": "rhs", + "nativeSrc": "37321:3:0", + "nodeType": "YulIdentifier", + "src": "37321:3:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "arguments": [ + { + "name": "INSTANCE_EVAL_MPTR", + "nativeSrc": "37346:18:0", + "nodeType": "YulIdentifier", + "src": "37346:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "37340:5:0", + "nodeType": "YulIdentifier", + "src": "37340:5:0" + }, + "nativeSrc": "37340:25:0", + "nodeType": "YulFunctionCall", + "src": "37340:25:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "37373:4:0", + "nodeType": "YulLiteral", + "src": "37373:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "37367:5:0", + "nodeType": "YulIdentifier", + "src": "37367:5:0" + }, + "nativeSrc": "37367:11:0", + "nodeType": "YulFunctionCall", + "src": "37367:11:0" + }, + { + "name": "r", + "nativeSrc": "37380:1:0", + "nodeType": "YulIdentifier", + "src": "37380:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "37333:6:0", + "nodeType": "YulIdentifier", + "src": "37333:6:0" + }, + "nativeSrc": "37333:49:0", + "nodeType": "YulFunctionCall", + "src": "37333:49:0" + }, + { + "name": "gamma", + "nativeSrc": "37384:5:0", + "nodeType": "YulIdentifier", + "src": "37384:5:0" + }, + { + "name": "r", + "nativeSrc": "37391:1:0", + "nodeType": "YulIdentifier", + "src": "37391:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "37326:6:0", + "nodeType": "YulIdentifier", + "src": "37326:6:0" + }, + "nativeSrc": "37326:67:0", + "nodeType": "YulFunctionCall", + "src": "37326:67:0" + }, + { + "name": "r", + "nativeSrc": "37395:1:0", + "nodeType": "YulIdentifier", + "src": "37395:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "37314:6:0", + "nodeType": "YulIdentifier", + "src": "37314:6:0" + }, + "nativeSrc": "37314:83:0", + "nodeType": "YulFunctionCall", + "src": "37314:83:0" + }, + "variableNames": [ + { + "name": "rhs", + "nativeSrc": "37307:3:0", + "nodeType": "YulIdentifier", + "src": "37307:3:0" + } + ] + }, + { + "nativeSrc": "37418:49:0", + "nodeType": "YulVariableDeclaration", + "src": "37418:49:0", + "value": { + "arguments": [ + { + "name": "lhs", + "nativeSrc": "37447:3:0", + "nodeType": "YulIdentifier", + "src": "37447:3:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "37456:1:0", + "nodeType": "YulIdentifier", + "src": "37456:1:0" + }, + { + "name": "rhs", + "nativeSrc": "37459:3:0", + "nodeType": "YulIdentifier", + "src": "37459:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "37452:3:0", + "nodeType": "YulIdentifier", + "src": "37452:3:0" + }, + "nativeSrc": "37452:11:0", + "nodeType": "YulFunctionCall", + "src": "37452:11:0" + }, + { + "name": "r", + "nativeSrc": "37465:1:0", + "nodeType": "YulIdentifier", + "src": "37465:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "37440:6:0", + "nodeType": "YulIdentifier", + "src": "37440:6:0" + }, + "nativeSrc": "37440:27:0", + "nodeType": "YulFunctionCall", + "src": "37440:27:0" + }, + "variables": [ + { + "name": "left_sub_right", + "nativeSrc": "37422:14:0", + "nodeType": "YulTypedName", + "src": "37422:14:0", + "type": "" + } + ] + }, + { + "nativeSrc": "37488:124:0", + "nodeType": "YulVariableDeclaration", + "src": "37488:124:0", + "value": { + "arguments": [ + { + "name": "left_sub_right", + "nativeSrc": "37507:14:0", + "nodeType": "YulIdentifier", + "src": "37507:14:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "37527:1:0", + "nodeType": "YulIdentifier", + "src": "37527:1:0" + }, + { + "arguments": [ + { + "name": "left_sub_right", + "nativeSrc": "37537:14:0", + "nodeType": "YulIdentifier", + "src": "37537:14:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "L_LAST_MPTR", + "nativeSrc": "37566:11:0", + "nodeType": "YulIdentifier", + "src": "37566:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "37560:5:0", + "nodeType": "YulIdentifier", + "src": "37560:5:0" + }, + "nativeSrc": "37560:18:0", + "nodeType": "YulFunctionCall", + "src": "37560:18:0" + }, + { + "arguments": [ + { + "name": "L_BLIND_MPTR", + "nativeSrc": "37586:12:0", + "nodeType": "YulIdentifier", + "src": "37586:12:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "37580:5:0", + "nodeType": "YulIdentifier", + "src": "37580:5:0" + }, + "nativeSrc": "37580:19:0", + "nodeType": "YulFunctionCall", + "src": "37580:19:0" + }, + { + "name": "r", + "nativeSrc": "37601:1:0", + "nodeType": "YulIdentifier", + "src": "37601:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "37553:6:0", + "nodeType": "YulIdentifier", + "src": "37553:6:0" + }, + "nativeSrc": "37553:50:0", + "nodeType": "YulFunctionCall", + "src": "37553:50:0" + }, + { + "name": "r", + "nativeSrc": "37605:1:0", + "nodeType": "YulIdentifier", + "src": "37605:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "37530:6:0", + "nodeType": "YulIdentifier", + "src": "37530:6:0" + }, + "nativeSrc": "37530:77:0", + "nodeType": "YulFunctionCall", + "src": "37530:77:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "37523:3:0", + "nodeType": "YulIdentifier", + "src": "37523:3:0" + }, + "nativeSrc": "37523:85:0", + "nodeType": "YulFunctionCall", + "src": "37523:85:0" + }, + { + "name": "r", + "nativeSrc": "37610:1:0", + "nodeType": "YulIdentifier", + "src": "37610:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "37500:6:0", + "nodeType": "YulIdentifier", + "src": "37500:6:0" + }, + "nativeSrc": "37500:112:0", + "nodeType": "YulFunctionCall", + "src": "37500:112:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "37492:4:0", + "nodeType": "YulTypedName", + "src": "37492:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "37633:73:0", + "nodeType": "YulAssignment", + "src": "37633:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "37670:19:0", + "nodeType": "YulIdentifier", + "src": "37670:19:0" + }, + { + "name": "y", + "nativeSrc": "37691:1:0", + "nodeType": "YulIdentifier", + "src": "37691:1:0" + }, + { + "name": "r", + "nativeSrc": "37694:1:0", + "nodeType": "YulIdentifier", + "src": "37694:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "37663:6:0", + "nodeType": "YulIdentifier", + "src": "37663:6:0" + }, + "nativeSrc": "37663:33:0", + "nodeType": "YulFunctionCall", + "src": "37663:33:0" + }, + { + "name": "eval", + "nativeSrc": "37698:4:0", + "nodeType": "YulIdentifier", + "src": "37698:4:0" + }, + { + "name": "r", + "nativeSrc": "37704:1:0", + "nodeType": "YulIdentifier", + "src": "37704:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "37656:6:0", + "nodeType": "YulIdentifier", + "src": "37656:6:0" + }, + "nativeSrc": "37656:50:0", + "nodeType": "YulFunctionCall", + "src": "37656:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "37633:19:0", + "nodeType": "YulIdentifier", + "src": "37633:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "37741:229:0", + "nodeType": "YulBlock", + "src": "37741:229:0", + "statements": [ + { + "nativeSrc": "37763:26:0", + "nodeType": "YulVariableDeclaration", + "src": "37763:26:0", + "value": { + "arguments": [ + { + "name": "L_0_MPTR", + "nativeSrc": "37780:8:0", + "nodeType": "YulIdentifier", + "src": "37780:8:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "37774:5:0", + "nodeType": "YulIdentifier", + "src": "37774:5:0" + }, + "nativeSrc": "37774:15:0", + "nodeType": "YulFunctionCall", + "src": "37774:15:0" + }, + "variables": [ + { + "name": "l_0", + "nativeSrc": "37767:3:0", + "nodeType": "YulTypedName", + "src": "37767:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "37810:48:0", + "nodeType": "YulVariableDeclaration", + "src": "37810:48:0", + "value": { + "arguments": [ + { + "name": "l_0", + "nativeSrc": "37829:3:0", + "nodeType": "YulIdentifier", + "src": "37829:3:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "37847:6:0", + "nodeType": "YulLiteral", + "src": "37847:6:0", + "type": "", + "value": "0x07c4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "37834:12:0", + "nodeType": "YulIdentifier", + "src": "37834:12:0" + }, + "nativeSrc": "37834:20:0", + "nodeType": "YulFunctionCall", + "src": "37834:20:0" + }, + { + "name": "r", + "nativeSrc": "37856:1:0", + "nodeType": "YulIdentifier", + "src": "37856:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "37822:6:0", + "nodeType": "YulIdentifier", + "src": "37822:6:0" + }, + "nativeSrc": "37822:36:0", + "nodeType": "YulFunctionCall", + "src": "37822:36:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "37814:4:0", + "nodeType": "YulTypedName", + "src": "37814:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "37879:73:0", + "nodeType": "YulAssignment", + "src": "37879:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "37916:19:0", + "nodeType": "YulIdentifier", + "src": "37916:19:0" + }, + { + "name": "y", + "nativeSrc": "37937:1:0", + "nodeType": "YulIdentifier", + "src": "37937:1:0" + }, + { + "name": "r", + "nativeSrc": "37940:1:0", + "nodeType": "YulIdentifier", + "src": "37940:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "37909:6:0", + "nodeType": "YulIdentifier", + "src": "37909:6:0" + }, + "nativeSrc": "37909:33:0", + "nodeType": "YulFunctionCall", + "src": "37909:33:0" + }, + { + "name": "eval", + "nativeSrc": "37944:4:0", + "nodeType": "YulIdentifier", + "src": "37944:4:0" + }, + { + "name": "r", + "nativeSrc": "37950:1:0", + "nodeType": "YulIdentifier", + "src": "37950:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "37902:6:0", + "nodeType": "YulIdentifier", + "src": "37902:6:0" + }, + "nativeSrc": "37902:50:0", + "nodeType": "YulFunctionCall", + "src": "37902:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "37879:19:0", + "nodeType": "YulIdentifier", + "src": "37879:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "37987:238:0", + "nodeType": "YulBlock", + "src": "37987:238:0", + "statements": [ + { + "nativeSrc": "38009:32:0", + "nodeType": "YulVariableDeclaration", + "src": "38009:32:0", + "value": { + "arguments": [ + { + "name": "L_LAST_MPTR", + "nativeSrc": "38029:11:0", + "nodeType": "YulIdentifier", + "src": "38029:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "38023:5:0", + "nodeType": "YulIdentifier", + "src": "38023:5:0" + }, + "nativeSrc": "38023:18:0", + "nodeType": "YulFunctionCall", + "src": "38023:18:0" + }, + "variables": [ + { + "name": "l_last", + "nativeSrc": "38013:6:0", + "nodeType": "YulTypedName", + "src": "38013:6:0", + "type": "" + } + ] + }, + { + "nativeSrc": "38062:51:0", + "nodeType": "YulVariableDeclaration", + "src": "38062:51:0", + "value": { + "arguments": [ + { + "name": "l_last", + "nativeSrc": "38081:6:0", + "nodeType": "YulIdentifier", + "src": "38081:6:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "38102:6:0", + "nodeType": "YulLiteral", + "src": "38102:6:0", + "type": "", + "value": "0x07c4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "38089:12:0", + "nodeType": "YulIdentifier", + "src": "38089:12:0" + }, + "nativeSrc": "38089:20:0", + "nodeType": "YulFunctionCall", + "src": "38089:20:0" + }, + { + "name": "r", + "nativeSrc": "38111:1:0", + "nodeType": "YulIdentifier", + "src": "38111:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "38074:6:0", + "nodeType": "YulIdentifier", + "src": "38074:6:0" + }, + "nativeSrc": "38074:39:0", + "nodeType": "YulFunctionCall", + "src": "38074:39:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "38066:4:0", + "nodeType": "YulTypedName", + "src": "38066:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "38134:73:0", + "nodeType": "YulAssignment", + "src": "38134:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "38171:19:0", + "nodeType": "YulIdentifier", + "src": "38171:19:0" + }, + { + "name": "y", + "nativeSrc": "38192:1:0", + "nodeType": "YulIdentifier", + "src": "38192:1:0" + }, + { + "name": "r", + "nativeSrc": "38195:1:0", + "nodeType": "YulIdentifier", + "src": "38195:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "38164:6:0", + "nodeType": "YulIdentifier", + "src": "38164:6:0" + }, + "nativeSrc": "38164:33:0", + "nodeType": "YulFunctionCall", + "src": "38164:33:0" + }, + { + "name": "eval", + "nativeSrc": "38199:4:0", + "nodeType": "YulIdentifier", + "src": "38199:4:0" + }, + { + "name": "r", + "nativeSrc": "38205:1:0", + "nodeType": "YulIdentifier", + "src": "38205:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "38157:6:0", + "nodeType": "YulIdentifier", + "src": "38157:6:0" + }, + "nativeSrc": "38157:50:0", + "nodeType": "YulFunctionCall", + "src": "38157:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "38134:19:0", + "nodeType": "YulIdentifier", + "src": "38134:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "38242:1958:0", + "nodeType": "YulBlock", + "src": "38242:1958:0", + "statements": [ + { + "nativeSrc": "38264:30:0", + "nodeType": "YulVariableDeclaration", + "src": "38264:30:0", + "value": { + "arguments": [ + { + "name": "THETA_MPTR", + "nativeSrc": "38283:10:0", + "nodeType": "YulIdentifier", + "src": "38283:10:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "38277:5:0", + "nodeType": "YulIdentifier", + "src": "38277:5:0" + }, + "nativeSrc": "38277:17:0", + "nodeType": "YulFunctionCall", + "src": "38277:17:0" + }, + "variables": [ + { + "name": "theta", + "nativeSrc": "38268:5:0", + "nodeType": "YulTypedName", + "src": "38268:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "38315:28:0", + "nodeType": "YulVariableDeclaration", + "src": "38315:28:0", + "value": { + "arguments": [ + { + "name": "BETA_MPTR", + "nativeSrc": "38333:9:0", + "nodeType": "YulIdentifier", + "src": "38333:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "38327:5:0", + "nodeType": "YulIdentifier", + "src": "38327:5:0" + }, + "nativeSrc": "38327:16:0", + "nodeType": "YulFunctionCall", + "src": "38327:16:0" + }, + "variables": [ + { + "name": "beta", + "nativeSrc": "38319:4:0", + "nodeType": "YulTypedName", + "src": "38319:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "38364:9:0", + "nodeType": "YulVariableDeclaration", + "src": "38364:9:0", + "variables": [ + { + "name": "table", + "nativeSrc": "38368:5:0", + "nodeType": "YulTypedName", + "src": "38368:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "38394:301:0", + "nodeType": "YulBlock", + "src": "38394:301:0", + "statements": [ + { + "nativeSrc": "38420:31:0", + "nodeType": "YulVariableDeclaration", + "src": "38420:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "38444:6:0", + "nodeType": "YulLiteral", + "src": "38444:6:0", + "type": "", + "value": "0x0504" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "38431:12:0", + "nodeType": "YulIdentifier", + "src": "38431:12:0" + }, + "nativeSrc": "38431:20:0", + "nodeType": "YulFunctionCall", + "src": "38431:20:0" + }, + "variables": [ + { + "name": "f_1", + "nativeSrc": "38424:3:0", + "nodeType": "YulTypedName", + "src": "38424:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "38476:31:0", + "nodeType": "YulVariableDeclaration", + "src": "38476:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "38500:6:0", + "nodeType": "YulLiteral", + "src": "38500:6:0", + "type": "", + "value": "0x0524" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "38487:12:0", + "nodeType": "YulIdentifier", + "src": "38487:12:0" + }, + "nativeSrc": "38487:20:0", + "nodeType": "YulFunctionCall", + "src": "38487:20:0" + }, + "variables": [ + { + "name": "f_2", + "nativeSrc": "38480:3:0", + "nodeType": "YulTypedName", + "src": "38480:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "38532:12:0", + "nodeType": "YulAssignment", + "src": "38532:12:0", + "value": { + "name": "f_1", + "nativeSrc": "38541:3:0", + "nodeType": "YulIdentifier", + "src": "38541:3:0" + }, + "variableNames": [ + { + "name": "table", + "nativeSrc": "38532:5:0", + "nodeType": "YulIdentifier", + "src": "38532:5:0" + } + ] + }, + { + "nativeSrc": "38569:48:0", + "nodeType": "YulAssignment", + "src": "38569:48:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "table", + "nativeSrc": "38592:5:0", + "nodeType": "YulIdentifier", + "src": "38592:5:0" + }, + { + "name": "theta", + "nativeSrc": "38599:5:0", + "nodeType": "YulIdentifier", + "src": "38599:5:0" + }, + { + "name": "r", + "nativeSrc": "38606:1:0", + "nodeType": "YulIdentifier", + "src": "38606:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "38585:6:0", + "nodeType": "YulIdentifier", + "src": "38585:6:0" + }, + "nativeSrc": "38585:23:0", + "nodeType": "YulFunctionCall", + "src": "38585:23:0" + }, + { + "name": "f_2", + "nativeSrc": "38610:3:0", + "nodeType": "YulIdentifier", + "src": "38610:3:0" + }, + { + "name": "r", + "nativeSrc": "38615:1:0", + "nodeType": "YulIdentifier", + "src": "38615:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "38578:6:0", + "nodeType": "YulIdentifier", + "src": "38578:6:0" + }, + "nativeSrc": "38578:39:0", + "nodeType": "YulFunctionCall", + "src": "38578:39:0" + }, + "variableNames": [ + { + "name": "table", + "nativeSrc": "38569:5:0", + "nodeType": "YulIdentifier", + "src": "38569:5:0" + } + ] + }, + { + "nativeSrc": "38642:31:0", + "nodeType": "YulAssignment", + "src": "38642:31:0", + "value": { + "arguments": [ + { + "name": "table", + "nativeSrc": "38658:5:0", + "nodeType": "YulIdentifier", + "src": "38658:5:0" + }, + { + "name": "beta", + "nativeSrc": "38665:4:0", + "nodeType": "YulIdentifier", + "src": "38665:4:0" + }, + { + "name": "r", + "nativeSrc": "38671:1:0", + "nodeType": "YulIdentifier", + "src": "38671:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "38651:6:0", + "nodeType": "YulIdentifier", + "src": "38651:6:0" + }, + "nativeSrc": "38651:22:0", + "nodeType": "YulFunctionCall", + "src": "38651:22:0" + }, + "variableNames": [ + { + "name": "table", + "nativeSrc": "38642:5:0", + "nodeType": "YulIdentifier", + "src": "38642:5:0" + } + ] + } + ] + }, + { + "nativeSrc": "38716:11:0", + "nodeType": "YulVariableDeclaration", + "src": "38716:11:0", + "variables": [ + { + "name": "input_0", + "nativeSrc": "38720:7:0", + "nodeType": "YulTypedName", + "src": "38720:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "38748:800:0", + "nodeType": "YulBlock", + "src": "38748:800:0", + "statements": [ + { + "nativeSrc": "38774:31:0", + "nodeType": "YulVariableDeclaration", + "src": "38774:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "38798:6:0", + "nodeType": "YulLiteral", + "src": "38798:6:0", + "type": "", + "value": "0x0584" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "38785:12:0", + "nodeType": "YulIdentifier", + "src": "38785:12:0" + }, + "nativeSrc": "38785:20:0", + "nodeType": "YulFunctionCall", + "src": "38785:20:0" + }, + "variables": [ + { + "name": "f_5", + "nativeSrc": "38778:3:0", + "nodeType": "YulTypedName", + "src": "38778:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "38830:31:0", + "nodeType": "YulVariableDeclaration", + "src": "38830:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "38854:6:0", + "nodeType": "YulLiteral", + "src": "38854:6:0", + "type": "", + "value": "0x0464" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "38841:12:0", + "nodeType": "YulIdentifier", + "src": "38841:12:0" + }, + "nativeSrc": "38841:20:0", + "nodeType": "YulFunctionCall", + "src": "38841:20:0" + }, + "variables": [ + { + "name": "a_0", + "nativeSrc": "38834:3:0", + "nodeType": "YulTypedName", + "src": "38834:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "38886:31:0", + "nodeType": "YulVariableDeclaration", + "src": "38886:31:0", + "value": { + "arguments": [ + { + "name": "f_5", + "nativeSrc": "38905:3:0", + "nodeType": "YulIdentifier", + "src": "38905:3:0" + }, + { + "name": "a_0", + "nativeSrc": "38910:3:0", + "nodeType": "YulIdentifier", + "src": "38910:3:0" + }, + { + "name": "r", + "nativeSrc": "38915:1:0", + "nodeType": "YulIdentifier", + "src": "38915:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "38898:6:0", + "nodeType": "YulIdentifier", + "src": "38898:6:0" + }, + "nativeSrc": "38898:19:0", + "nodeType": "YulFunctionCall", + "src": "38898:19:0" + }, + "variables": [ + { + "name": "var0", + "nativeSrc": "38890:4:0", + "nodeType": "YulTypedName", + "src": "38890:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "38942:15:0", + "nodeType": "YulVariableDeclaration", + "src": "38942:15:0", + "value": { + "kind": "number", + "nativeSrc": "38954:3:0", + "nodeType": "YulLiteral", + "src": "38954:3:0", + "type": "", + "value": "0x1" + }, + "variables": [ + { + "name": "var1", + "nativeSrc": "38946:4:0", + "nodeType": "YulTypedName", + "src": "38946:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "38982:23:0", + "nodeType": "YulVariableDeclaration", + "src": "38982:23:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "38998:1:0", + "nodeType": "YulIdentifier", + "src": "38998:1:0" + }, + { + "name": "f_5", + "nativeSrc": "39001:3:0", + "nodeType": "YulIdentifier", + "src": "39001:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "38994:3:0", + "nodeType": "YulIdentifier", + "src": "38994:3:0" + }, + "nativeSrc": "38994:11:0", + "nodeType": "YulFunctionCall", + "src": "38994:11:0" + }, + "variables": [ + { + "name": "var2", + "nativeSrc": "38986:4:0", + "nodeType": "YulTypedName", + "src": "38986:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "39030:33:0", + "nodeType": "YulVariableDeclaration", + "src": "39030:33:0", + "value": { + "arguments": [ + { + "name": "var1", + "nativeSrc": "39049:4:0", + "nodeType": "YulIdentifier", + "src": "39049:4:0" + }, + { + "name": "var2", + "nativeSrc": "39055:4:0", + "nodeType": "YulIdentifier", + "src": "39055:4:0" + }, + { + "name": "r", + "nativeSrc": "39061:1:0", + "nodeType": "YulIdentifier", + "src": "39061:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "39042:6:0", + "nodeType": "YulIdentifier", + "src": "39042:6:0" + }, + "nativeSrc": "39042:21:0", + "nodeType": "YulFunctionCall", + "src": "39042:21:0" + }, + "variables": [ + { + "name": "var3", + "nativeSrc": "39034:4:0", + "nodeType": "YulTypedName", + "src": "39034:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "39088:32:0", + "nodeType": "YulVariableDeclaration", + "src": "39088:32:0", + "value": { + "arguments": [ + { + "name": "var3", + "nativeSrc": "39107:4:0", + "nodeType": "YulIdentifier", + "src": "39107:4:0" + }, + { + "kind": "number", + "nativeSrc": "39113:3:0", + "nodeType": "YulLiteral", + "src": "39113:3:0", + "type": "", + "value": "0x0" + }, + { + "name": "r", + "nativeSrc": "39118:1:0", + "nodeType": "YulIdentifier", + "src": "39118:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "39100:6:0", + "nodeType": "YulIdentifier", + "src": "39100:6:0" + }, + "nativeSrc": "39100:20:0", + "nodeType": "YulFunctionCall", + "src": "39100:20:0" + }, + "variables": [ + { + "name": "var4", + "nativeSrc": "39092:4:0", + "nodeType": "YulTypedName", + "src": "39092:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "39145:33:0", + "nodeType": "YulVariableDeclaration", + "src": "39145:33:0", + "value": { + "arguments": [ + { + "name": "var0", + "nativeSrc": "39164:4:0", + "nodeType": "YulIdentifier", + "src": "39164:4:0" + }, + { + "name": "var4", + "nativeSrc": "39170:4:0", + "nodeType": "YulIdentifier", + "src": "39170:4:0" + }, + { + "name": "r", + "nativeSrc": "39176:1:0", + "nodeType": "YulIdentifier", + "src": "39176:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "39157:6:0", + "nodeType": "YulIdentifier", + "src": "39157:6:0" + }, + "nativeSrc": "39157:21:0", + "nodeType": "YulFunctionCall", + "src": "39157:21:0" + }, + "variables": [ + { + "name": "var5", + "nativeSrc": "39149:4:0", + "nodeType": "YulTypedName", + "src": "39149:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "39203:31:0", + "nodeType": "YulVariableDeclaration", + "src": "39203:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "39227:6:0", + "nodeType": "YulLiteral", + "src": "39227:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "39214:12:0", + "nodeType": "YulIdentifier", + "src": "39214:12:0" + }, + "nativeSrc": "39214:20:0", + "nodeType": "YulFunctionCall", + "src": "39214:20:0" + }, + "variables": [ + { + "name": "a_1", + "nativeSrc": "39207:3:0", + "nodeType": "YulTypedName", + "src": "39207:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "39259:31:0", + "nodeType": "YulVariableDeclaration", + "src": "39259:31:0", + "value": { + "arguments": [ + { + "name": "f_5", + "nativeSrc": "39278:3:0", + "nodeType": "YulIdentifier", + "src": "39278:3:0" + }, + { + "name": "a_1", + "nativeSrc": "39283:3:0", + "nodeType": "YulIdentifier", + "src": "39283:3:0" + }, + { + "name": "r", + "nativeSrc": "39288:1:0", + "nodeType": "YulIdentifier", + "src": "39288:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "39271:6:0", + "nodeType": "YulIdentifier", + "src": "39271:6:0" + }, + "nativeSrc": "39271:19:0", + "nodeType": "YulFunctionCall", + "src": "39271:19:0" + }, + "variables": [ + { + "name": "var6", + "nativeSrc": "39263:4:0", + "nodeType": "YulTypedName", + "src": "39263:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "39315:33:0", + "nodeType": "YulVariableDeclaration", + "src": "39315:33:0", + "value": { + "arguments": [ + { + "name": "var6", + "nativeSrc": "39334:4:0", + "nodeType": "YulIdentifier", + "src": "39334:4:0" + }, + { + "name": "var4", + "nativeSrc": "39340:4:0", + "nodeType": "YulIdentifier", + "src": "39340:4:0" + }, + { + "name": "r", + "nativeSrc": "39346:1:0", + "nodeType": "YulIdentifier", + "src": "39346:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "39327:6:0", + "nodeType": "YulIdentifier", + "src": "39327:6:0" + }, + "nativeSrc": "39327:21:0", + "nodeType": "YulFunctionCall", + "src": "39327:21:0" + }, + "variables": [ + { + "name": "var7", + "nativeSrc": "39319:4:0", + "nodeType": "YulTypedName", + "src": "39319:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "39373:15:0", + "nodeType": "YulAssignment", + "src": "39373:15:0", + "value": { + "name": "var5", + "nativeSrc": "39384:4:0", + "nodeType": "YulIdentifier", + "src": "39384:4:0" + }, + "variableNames": [ + { + "name": "input_0", + "nativeSrc": "39373:7:0", + "nodeType": "YulIdentifier", + "src": "39373:7:0" + } + ] + }, + { + "nativeSrc": "39413:53:0", + "nodeType": "YulAssignment", + "src": "39413:53:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "input_0", + "nativeSrc": "39438:7:0", + "nodeType": "YulIdentifier", + "src": "39438:7:0" + }, + { + "name": "theta", + "nativeSrc": "39447:5:0", + "nodeType": "YulIdentifier", + "src": "39447:5:0" + }, + { + "name": "r", + "nativeSrc": "39454:1:0", + "nodeType": "YulIdentifier", + "src": "39454:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "39431:6:0", + "nodeType": "YulIdentifier", + "src": "39431:6:0" + }, + "nativeSrc": "39431:25:0", + "nodeType": "YulFunctionCall", + "src": "39431:25:0" + }, + { + "name": "var7", + "nativeSrc": "39458:4:0", + "nodeType": "YulIdentifier", + "src": "39458:4:0" + }, + { + "name": "r", + "nativeSrc": "39464:1:0", + "nodeType": "YulIdentifier", + "src": "39464:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "39424:6:0", + "nodeType": "YulIdentifier", + "src": "39424:6:0" + }, + "nativeSrc": "39424:42:0", + "nodeType": "YulFunctionCall", + "src": "39424:42:0" + }, + "variableNames": [ + { + "name": "input_0", + "nativeSrc": "39413:7:0", + "nodeType": "YulIdentifier", + "src": "39413:7:0" + } + ] + }, + { + "nativeSrc": "39491:35:0", + "nodeType": "YulAssignment", + "src": "39491:35:0", + "value": { + "arguments": [ + { + "name": "input_0", + "nativeSrc": "39509:7:0", + "nodeType": "YulIdentifier", + "src": "39509:7:0" + }, + { + "name": "beta", + "nativeSrc": "39518:4:0", + "nodeType": "YulIdentifier", + "src": "39518:4:0" + }, + { + "name": "r", + "nativeSrc": "39524:1:0", + "nodeType": "YulIdentifier", + "src": "39524:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "39502:6:0", + "nodeType": "YulIdentifier", + "src": "39502:6:0" + }, + "nativeSrc": "39502:24:0", + "nodeType": "YulFunctionCall", + "src": "39502:24:0" + }, + "variableNames": [ + { + "name": "input_0", + "nativeSrc": "39491:7:0", + "nodeType": "YulIdentifier", + "src": "39491:7:0" + } + ] + } + ] + }, + { + "nativeSrc": "39569:7:0", + "nodeType": "YulVariableDeclaration", + "src": "39569:7:0", + "variables": [ + { + "name": "lhs", + "nativeSrc": "39573:3:0", + "nodeType": "YulTypedName", + "src": "39573:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "39597:7:0", + "nodeType": "YulVariableDeclaration", + "src": "39597:7:0", + "variables": [ + { + "name": "rhs", + "nativeSrc": "39601:3:0", + "nodeType": "YulTypedName", + "src": "39601:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "39625:12:0", + "nodeType": "YulAssignment", + "src": "39625:12:0", + "value": { + "name": "table", + "nativeSrc": "39632:5:0", + "nodeType": "YulIdentifier", + "src": "39632:5:0" + }, + "variableNames": [ + { + "name": "rhs", + "nativeSrc": "39625:3:0", + "nodeType": "YulIdentifier", + "src": "39625:3:0" + } + ] + }, + { + "nativeSrc": "39658:285:0", + "nodeType": "YulBlock", + "src": "39658:285:0", + "statements": [ + { + "nativeSrc": "39684:18:0", + "nodeType": "YulVariableDeclaration", + "src": "39684:18:0", + "value": { + "name": "input_0", + "nativeSrc": "39695:7:0", + "nodeType": "YulIdentifier", + "src": "39695:7:0" + }, + "variables": [ + { + "name": "tmp", + "nativeSrc": "39688:3:0", + "nodeType": "YulTypedName", + "src": "39688:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "39727:67:0", + "nodeType": "YulAssignment", + "src": "39727:67:0", + "value": { + "arguments": [ + { + "name": "rhs", + "nativeSrc": "39741:3:0", + "nodeType": "YulIdentifier", + "src": "39741:3:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "39750:1:0", + "nodeType": "YulIdentifier", + "src": "39750:1:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "39773:6:0", + "nodeType": "YulLiteral", + "src": "39773:6:0", + "type": "", + "value": "0x0804" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "39760:12:0", + "nodeType": "YulIdentifier", + "src": "39760:12:0" + }, + "nativeSrc": "39760:20:0", + "nodeType": "YulFunctionCall", + "src": "39760:20:0" + }, + { + "name": "tmp", + "nativeSrc": "39782:3:0", + "nodeType": "YulIdentifier", + "src": "39782:3:0" + }, + { + "name": "r", + "nativeSrc": "39787:1:0", + "nodeType": "YulIdentifier", + "src": "39787:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "39753:6:0", + "nodeType": "YulIdentifier", + "src": "39753:6:0" + }, + "nativeSrc": "39753:36:0", + "nodeType": "YulFunctionCall", + "src": "39753:36:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "39746:3:0", + "nodeType": "YulIdentifier", + "src": "39746:3:0" + }, + "nativeSrc": "39746:44:0", + "nodeType": "YulFunctionCall", + "src": "39746:44:0" + }, + { + "name": "r", + "nativeSrc": "39792:1:0", + "nodeType": "YulIdentifier", + "src": "39792:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "39734:6:0", + "nodeType": "YulIdentifier", + "src": "39734:6:0" + }, + "nativeSrc": "39734:60:0", + "nodeType": "YulFunctionCall", + "src": "39734:60:0" + }, + "variableNames": [ + { + "name": "rhs", + "nativeSrc": "39727:3:0", + "nodeType": "YulIdentifier", + "src": "39727:3:0" + } + ] + }, + { + "nativeSrc": "39819:102:0", + "nodeType": "YulAssignment", + "src": "39819:102:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "table", + "nativeSrc": "39840:5:0", + "nodeType": "YulIdentifier", + "src": "39840:5:0" + }, + { + "name": "tmp", + "nativeSrc": "39847:3:0", + "nodeType": "YulIdentifier", + "src": "39847:3:0" + }, + { + "name": "r", + "nativeSrc": "39852:1:0", + "nodeType": "YulIdentifier", + "src": "39852:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "39833:6:0", + "nodeType": "YulIdentifier", + "src": "39833:6:0" + }, + "nativeSrc": "39833:21:0", + "nodeType": "YulFunctionCall", + "src": "39833:21:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "39876:6:0", + "nodeType": "YulLiteral", + "src": "39876:6:0", + "type": "", + "value": "0x07e4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "39863:12:0", + "nodeType": "YulIdentifier", + "src": "39863:12:0" + }, + "nativeSrc": "39863:20:0", + "nodeType": "YulFunctionCall", + "src": "39863:20:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "39889:1:0", + "nodeType": "YulIdentifier", + "src": "39889:1:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "39905:6:0", + "nodeType": "YulLiteral", + "src": "39905:6:0", + "type": "", + "value": "0x07c4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "39892:12:0", + "nodeType": "YulIdentifier", + "src": "39892:12:0" + }, + "nativeSrc": "39892:20:0", + "nodeType": "YulFunctionCall", + "src": "39892:20:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "39885:3:0", + "nodeType": "YulIdentifier", + "src": "39885:3:0" + }, + "nativeSrc": "39885:28:0", + "nodeType": "YulFunctionCall", + "src": "39885:28:0" + }, + { + "name": "r", + "nativeSrc": "39915:1:0", + "nodeType": "YulIdentifier", + "src": "39915:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "39856:6:0", + "nodeType": "YulIdentifier", + "src": "39856:6:0" + }, + "nativeSrc": "39856:61:0", + "nodeType": "YulFunctionCall", + "src": "39856:61:0" + }, + { + "name": "r", + "nativeSrc": "39919:1:0", + "nodeType": "YulIdentifier", + "src": "39919:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "39826:6:0", + "nodeType": "YulIdentifier", + "src": "39826:6:0" + }, + "nativeSrc": "39826:95:0", + "nodeType": "YulFunctionCall", + "src": "39826:95:0" + }, + "variableNames": [ + { + "name": "lhs", + "nativeSrc": "39819:3:0", + "nodeType": "YulIdentifier", + "src": "39819:3:0" + } + ] + } + ] + }, + { + "nativeSrc": "39964:124:0", + "nodeType": "YulVariableDeclaration", + "src": "39964:124:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "39990:1:0", + "nodeType": "YulLiteral", + "src": "39990:1:0", + "type": "", + "value": "1" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "39997:1:0", + "nodeType": "YulIdentifier", + "src": "39997:1:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "L_BLIND_MPTR", + "nativeSrc": "40013:12:0", + "nodeType": "YulIdentifier", + "src": "40013:12:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "40007:5:0", + "nodeType": "YulIdentifier", + "src": "40007:5:0" + }, + "nativeSrc": "40007:19:0", + "nodeType": "YulFunctionCall", + "src": "40007:19:0" + }, + { + "arguments": [ + { + "name": "L_LAST_MPTR", + "nativeSrc": "40034:11:0", + "nodeType": "YulIdentifier", + "src": "40034:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "40028:5:0", + "nodeType": "YulIdentifier", + "src": "40028:5:0" + }, + "nativeSrc": "40028:18:0", + "nodeType": "YulFunctionCall", + "src": "40028:18:0" + }, + { + "name": "r", + "nativeSrc": "40048:1:0", + "nodeType": "YulIdentifier", + "src": "40048:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "40000:6:0", + "nodeType": "YulIdentifier", + "src": "40000:6:0" + }, + "nativeSrc": "40000:50:0", + "nodeType": "YulFunctionCall", + "src": "40000:50:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "39993:3:0", + "nodeType": "YulIdentifier", + "src": "39993:3:0" + }, + "nativeSrc": "39993:58:0", + "nodeType": "YulFunctionCall", + "src": "39993:58:0" + }, + { + "name": "r", + "nativeSrc": "40053:1:0", + "nodeType": "YulIdentifier", + "src": "40053:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "39983:6:0", + "nodeType": "YulIdentifier", + "src": "39983:6:0" + }, + "nativeSrc": "39983:72:0", + "nodeType": "YulFunctionCall", + "src": "39983:72:0" + }, + { + "arguments": [ + { + "name": "lhs", + "nativeSrc": "40064:3:0", + "nodeType": "YulIdentifier", + "src": "40064:3:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "40073:1:0", + "nodeType": "YulIdentifier", + "src": "40073:1:0" + }, + { + "name": "rhs", + "nativeSrc": "40076:3:0", + "nodeType": "YulIdentifier", + "src": "40076:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "40069:3:0", + "nodeType": "YulIdentifier", + "src": "40069:3:0" + }, + "nativeSrc": "40069:11:0", + "nodeType": "YulFunctionCall", + "src": "40069:11:0" + }, + { + "name": "r", + "nativeSrc": "40082:1:0", + "nodeType": "YulIdentifier", + "src": "40082:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "40057:6:0", + "nodeType": "YulIdentifier", + "src": "40057:6:0" + }, + "nativeSrc": "40057:27:0", + "nodeType": "YulFunctionCall", + "src": "40057:27:0" + }, + { + "name": "r", + "nativeSrc": "40086:1:0", + "nodeType": "YulIdentifier", + "src": "40086:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "39976:6:0", + "nodeType": "YulIdentifier", + "src": "39976:6:0" + }, + "nativeSrc": "39976:112:0", + "nodeType": "YulFunctionCall", + "src": "39976:112:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "39968:4:0", + "nodeType": "YulTypedName", + "src": "39968:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "40109:73:0", + "nodeType": "YulAssignment", + "src": "40109:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "40146:19:0", + "nodeType": "YulIdentifier", + "src": "40146:19:0" + }, + { + "name": "y", + "nativeSrc": "40167:1:0", + "nodeType": "YulIdentifier", + "src": "40167:1:0" + }, + { + "name": "r", + "nativeSrc": "40170:1:0", + "nodeType": "YulIdentifier", + "src": "40170:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "40139:6:0", + "nodeType": "YulIdentifier", + "src": "40139:6:0" + }, + "nativeSrc": "40139:33:0", + "nodeType": "YulFunctionCall", + "src": "40139:33:0" + }, + { + "name": "eval", + "nativeSrc": "40174:4:0", + "nodeType": "YulIdentifier", + "src": "40174:4:0" + }, + { + "name": "r", + "nativeSrc": "40180:1:0", + "nodeType": "YulIdentifier", + "src": "40180:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "40132:6:0", + "nodeType": "YulIdentifier", + "src": "40132:6:0" + }, + "nativeSrc": "40132:50:0", + "nodeType": "YulFunctionCall", + "src": "40132:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "40109:19:0", + "nodeType": "YulIdentifier", + "src": "40109:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "40217:229:0", + "nodeType": "YulBlock", + "src": "40217:229:0", + "statements": [ + { + "nativeSrc": "40239:26:0", + "nodeType": "YulVariableDeclaration", + "src": "40239:26:0", + "value": { + "arguments": [ + { + "name": "L_0_MPTR", + "nativeSrc": "40256:8:0", + "nodeType": "YulIdentifier", + "src": "40256:8:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "40250:5:0", + "nodeType": "YulIdentifier", + "src": "40250:5:0" + }, + "nativeSrc": "40250:15:0", + "nodeType": "YulFunctionCall", + "src": "40250:15:0" + }, + "variables": [ + { + "name": "l_0", + "nativeSrc": "40243:3:0", + "nodeType": "YulTypedName", + "src": "40243:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "40286:48:0", + "nodeType": "YulVariableDeclaration", + "src": "40286:48:0", + "value": { + "arguments": [ + { + "name": "l_0", + "nativeSrc": "40305:3:0", + "nodeType": "YulIdentifier", + "src": "40305:3:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "40323:6:0", + "nodeType": "YulLiteral", + "src": "40323:6:0", + "type": "", + "value": "0x0824" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "40310:12:0", + "nodeType": "YulIdentifier", + "src": "40310:12:0" + }, + "nativeSrc": "40310:20:0", + "nodeType": "YulFunctionCall", + "src": "40310:20:0" + }, + { + "name": "r", + "nativeSrc": "40332:1:0", + "nodeType": "YulIdentifier", + "src": "40332:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "40298:6:0", + "nodeType": "YulIdentifier", + "src": "40298:6:0" + }, + "nativeSrc": "40298:36:0", + "nodeType": "YulFunctionCall", + "src": "40298:36:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "40290:4:0", + "nodeType": "YulTypedName", + "src": "40290:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "40355:73:0", + "nodeType": "YulAssignment", + "src": "40355:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "40392:19:0", + "nodeType": "YulIdentifier", + "src": "40392:19:0" + }, + { + "name": "y", + "nativeSrc": "40413:1:0", + "nodeType": "YulIdentifier", + "src": "40413:1:0" + }, + { + "name": "r", + "nativeSrc": "40416:1:0", + "nodeType": "YulIdentifier", + "src": "40416:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "40385:6:0", + "nodeType": "YulIdentifier", + "src": "40385:6:0" + }, + "nativeSrc": "40385:33:0", + "nodeType": "YulFunctionCall", + "src": "40385:33:0" + }, + { + "name": "eval", + "nativeSrc": "40420:4:0", + "nodeType": "YulIdentifier", + "src": "40420:4:0" + }, + { + "name": "r", + "nativeSrc": "40426:1:0", + "nodeType": "YulIdentifier", + "src": "40426:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "40378:6:0", + "nodeType": "YulIdentifier", + "src": "40378:6:0" + }, + "nativeSrc": "40378:50:0", + "nodeType": "YulFunctionCall", + "src": "40378:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "40355:19:0", + "nodeType": "YulIdentifier", + "src": "40355:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "40463:238:0", + "nodeType": "YulBlock", + "src": "40463:238:0", + "statements": [ + { + "nativeSrc": "40485:32:0", + "nodeType": "YulVariableDeclaration", + "src": "40485:32:0", + "value": { + "arguments": [ + { + "name": "L_LAST_MPTR", + "nativeSrc": "40505:11:0", + "nodeType": "YulIdentifier", + "src": "40505:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "40499:5:0", + "nodeType": "YulIdentifier", + "src": "40499:5:0" + }, + "nativeSrc": "40499:18:0", + "nodeType": "YulFunctionCall", + "src": "40499:18:0" + }, + "variables": [ + { + "name": "l_last", + "nativeSrc": "40489:6:0", + "nodeType": "YulTypedName", + "src": "40489:6:0", + "type": "" + } + ] + }, + { + "nativeSrc": "40538:51:0", + "nodeType": "YulVariableDeclaration", + "src": "40538:51:0", + "value": { + "arguments": [ + { + "name": "l_last", + "nativeSrc": "40557:6:0", + "nodeType": "YulIdentifier", + "src": "40557:6:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "40578:6:0", + "nodeType": "YulLiteral", + "src": "40578:6:0", + "type": "", + "value": "0x0824" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "40565:12:0", + "nodeType": "YulIdentifier", + "src": "40565:12:0" + }, + "nativeSrc": "40565:20:0", + "nodeType": "YulFunctionCall", + "src": "40565:20:0" + }, + { + "name": "r", + "nativeSrc": "40587:1:0", + "nodeType": "YulIdentifier", + "src": "40587:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "40550:6:0", + "nodeType": "YulIdentifier", + "src": "40550:6:0" + }, + "nativeSrc": "40550:39:0", + "nodeType": "YulFunctionCall", + "src": "40550:39:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "40542:4:0", + "nodeType": "YulTypedName", + "src": "40542:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "40610:73:0", + "nodeType": "YulAssignment", + "src": "40610:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "40647:19:0", + "nodeType": "YulIdentifier", + "src": "40647:19:0" + }, + { + "name": "y", + "nativeSrc": "40668:1:0", + "nodeType": "YulIdentifier", + "src": "40668:1:0" + }, + { + "name": "r", + "nativeSrc": "40671:1:0", + "nodeType": "YulIdentifier", + "src": "40671:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "40640:6:0", + "nodeType": "YulIdentifier", + "src": "40640:6:0" + }, + "nativeSrc": "40640:33:0", + "nodeType": "YulFunctionCall", + "src": "40640:33:0" + }, + { + "name": "eval", + "nativeSrc": "40675:4:0", + "nodeType": "YulIdentifier", + "src": "40675:4:0" + }, + { + "name": "r", + "nativeSrc": "40681:1:0", + "nodeType": "YulIdentifier", + "src": "40681:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "40633:6:0", + "nodeType": "YulIdentifier", + "src": "40633:6:0" + }, + "nativeSrc": "40633:50:0", + "nodeType": "YulFunctionCall", + "src": "40633:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "40610:19:0", + "nodeType": "YulIdentifier", + "src": "40610:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "40718:1958:0", + "nodeType": "YulBlock", + "src": "40718:1958:0", + "statements": [ + { + "nativeSrc": "40740:30:0", + "nodeType": "YulVariableDeclaration", + "src": "40740:30:0", + "value": { + "arguments": [ + { + "name": "THETA_MPTR", + "nativeSrc": "40759:10:0", + "nodeType": "YulIdentifier", + "src": "40759:10:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "40753:5:0", + "nodeType": "YulIdentifier", + "src": "40753:5:0" + }, + "nativeSrc": "40753:17:0", + "nodeType": "YulFunctionCall", + "src": "40753:17:0" + }, + "variables": [ + { + "name": "theta", + "nativeSrc": "40744:5:0", + "nodeType": "YulTypedName", + "src": "40744:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "40791:28:0", + "nodeType": "YulVariableDeclaration", + "src": "40791:28:0", + "value": { + "arguments": [ + { + "name": "BETA_MPTR", + "nativeSrc": "40809:9:0", + "nodeType": "YulIdentifier", + "src": "40809:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "40803:5:0", + "nodeType": "YulIdentifier", + "src": "40803:5:0" + }, + "nativeSrc": "40803:16:0", + "nodeType": "YulFunctionCall", + "src": "40803:16:0" + }, + "variables": [ + { + "name": "beta", + "nativeSrc": "40795:4:0", + "nodeType": "YulTypedName", + "src": "40795:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "40840:9:0", + "nodeType": "YulVariableDeclaration", + "src": "40840:9:0", + "variables": [ + { + "name": "table", + "nativeSrc": "40844:5:0", + "nodeType": "YulTypedName", + "src": "40844:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "40870:301:0", + "nodeType": "YulBlock", + "src": "40870:301:0", + "statements": [ + { + "nativeSrc": "40896:31:0", + "nodeType": "YulVariableDeclaration", + "src": "40896:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "40920:6:0", + "nodeType": "YulLiteral", + "src": "40920:6:0", + "type": "", + "value": "0x0504" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "40907:12:0", + "nodeType": "YulIdentifier", + "src": "40907:12:0" + }, + "nativeSrc": "40907:20:0", + "nodeType": "YulFunctionCall", + "src": "40907:20:0" + }, + "variables": [ + { + "name": "f_1", + "nativeSrc": "40900:3:0", + "nodeType": "YulTypedName", + "src": "40900:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "40952:31:0", + "nodeType": "YulVariableDeclaration", + "src": "40952:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "40976:6:0", + "nodeType": "YulLiteral", + "src": "40976:6:0", + "type": "", + "value": "0x0544" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "40963:12:0", + "nodeType": "YulIdentifier", + "src": "40963:12:0" + }, + "nativeSrc": "40963:20:0", + "nodeType": "YulFunctionCall", + "src": "40963:20:0" + }, + "variables": [ + { + "name": "f_3", + "nativeSrc": "40956:3:0", + "nodeType": "YulTypedName", + "src": "40956:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "41008:12:0", + "nodeType": "YulAssignment", + "src": "41008:12:0", + "value": { + "name": "f_1", + "nativeSrc": "41017:3:0", + "nodeType": "YulIdentifier", + "src": "41017:3:0" + }, + "variableNames": [ + { + "name": "table", + "nativeSrc": "41008:5:0", + "nodeType": "YulIdentifier", + "src": "41008:5:0" + } + ] + }, + { + "nativeSrc": "41045:48:0", + "nodeType": "YulAssignment", + "src": "41045:48:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "table", + "nativeSrc": "41068:5:0", + "nodeType": "YulIdentifier", + "src": "41068:5:0" + }, + { + "name": "theta", + "nativeSrc": "41075:5:0", + "nodeType": "YulIdentifier", + "src": "41075:5:0" + }, + { + "name": "r", + "nativeSrc": "41082:1:0", + "nodeType": "YulIdentifier", + "src": "41082:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "41061:6:0", + "nodeType": "YulIdentifier", + "src": "41061:6:0" + }, + "nativeSrc": "41061:23:0", + "nodeType": "YulFunctionCall", + "src": "41061:23:0" + }, + { + "name": "f_3", + "nativeSrc": "41086:3:0", + "nodeType": "YulIdentifier", + "src": "41086:3:0" + }, + { + "name": "r", + "nativeSrc": "41091:1:0", + "nodeType": "YulIdentifier", + "src": "41091:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "41054:6:0", + "nodeType": "YulIdentifier", + "src": "41054:6:0" + }, + "nativeSrc": "41054:39:0", + "nodeType": "YulFunctionCall", + "src": "41054:39:0" + }, + "variableNames": [ + { + "name": "table", + "nativeSrc": "41045:5:0", + "nodeType": "YulIdentifier", + "src": "41045:5:0" + } + ] + }, + { + "nativeSrc": "41118:31:0", + "nodeType": "YulAssignment", + "src": "41118:31:0", + "value": { + "arguments": [ + { + "name": "table", + "nativeSrc": "41134:5:0", + "nodeType": "YulIdentifier", + "src": "41134:5:0" + }, + { + "name": "beta", + "nativeSrc": "41141:4:0", + "nodeType": "YulIdentifier", + "src": "41141:4:0" + }, + { + "name": "r", + "nativeSrc": "41147:1:0", + "nodeType": "YulIdentifier", + "src": "41147:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "41127:6:0", + "nodeType": "YulIdentifier", + "src": "41127:6:0" + }, + "nativeSrc": "41127:22:0", + "nodeType": "YulFunctionCall", + "src": "41127:22:0" + }, + "variableNames": [ + { + "name": "table", + "nativeSrc": "41118:5:0", + "nodeType": "YulIdentifier", + "src": "41118:5:0" + } + ] + } + ] + }, + { + "nativeSrc": "41192:11:0", + "nodeType": "YulVariableDeclaration", + "src": "41192:11:0", + "variables": [ + { + "name": "input_0", + "nativeSrc": "41196:7:0", + "nodeType": "YulTypedName", + "src": "41196:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "41224:800:0", + "nodeType": "YulBlock", + "src": "41224:800:0", + "statements": [ + { + "nativeSrc": "41250:31:0", + "nodeType": "YulVariableDeclaration", + "src": "41250:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "41274:6:0", + "nodeType": "YulLiteral", + "src": "41274:6:0", + "type": "", + "value": "0x05a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "41261:12:0", + "nodeType": "YulIdentifier", + "src": "41261:12:0" + }, + "nativeSrc": "41261:20:0", + "nodeType": "YulFunctionCall", + "src": "41261:20:0" + }, + "variables": [ + { + "name": "f_6", + "nativeSrc": "41254:3:0", + "nodeType": "YulTypedName", + "src": "41254:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "41306:31:0", + "nodeType": "YulVariableDeclaration", + "src": "41306:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "41330:6:0", + "nodeType": "YulLiteral", + "src": "41330:6:0", + "type": "", + "value": "0x0464" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "41317:12:0", + "nodeType": "YulIdentifier", + "src": "41317:12:0" + }, + "nativeSrc": "41317:20:0", + "nodeType": "YulFunctionCall", + "src": "41317:20:0" + }, + "variables": [ + { + "name": "a_0", + "nativeSrc": "41310:3:0", + "nodeType": "YulTypedName", + "src": "41310:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "41362:31:0", + "nodeType": "YulVariableDeclaration", + "src": "41362:31:0", + "value": { + "arguments": [ + { + "name": "f_6", + "nativeSrc": "41381:3:0", + "nodeType": "YulIdentifier", + "src": "41381:3:0" + }, + { + "name": "a_0", + "nativeSrc": "41386:3:0", + "nodeType": "YulIdentifier", + "src": "41386:3:0" + }, + { + "name": "r", + "nativeSrc": "41391:1:0", + "nodeType": "YulIdentifier", + "src": "41391:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "41374:6:0", + "nodeType": "YulIdentifier", + "src": "41374:6:0" + }, + "nativeSrc": "41374:19:0", + "nodeType": "YulFunctionCall", + "src": "41374:19:0" + }, + "variables": [ + { + "name": "var0", + "nativeSrc": "41366:4:0", + "nodeType": "YulTypedName", + "src": "41366:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "41418:15:0", + "nodeType": "YulVariableDeclaration", + "src": "41418:15:0", + "value": { + "kind": "number", + "nativeSrc": "41430:3:0", + "nodeType": "YulLiteral", + "src": "41430:3:0", + "type": "", + "value": "0x1" + }, + "variables": [ + { + "name": "var1", + "nativeSrc": "41422:4:0", + "nodeType": "YulTypedName", + "src": "41422:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "41458:23:0", + "nodeType": "YulVariableDeclaration", + "src": "41458:23:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "41474:1:0", + "nodeType": "YulIdentifier", + "src": "41474:1:0" + }, + { + "name": "f_6", + "nativeSrc": "41477:3:0", + "nodeType": "YulIdentifier", + "src": "41477:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "41470:3:0", + "nodeType": "YulIdentifier", + "src": "41470:3:0" + }, + "nativeSrc": "41470:11:0", + "nodeType": "YulFunctionCall", + "src": "41470:11:0" + }, + "variables": [ + { + "name": "var2", + "nativeSrc": "41462:4:0", + "nodeType": "YulTypedName", + "src": "41462:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "41506:33:0", + "nodeType": "YulVariableDeclaration", + "src": "41506:33:0", + "value": { + "arguments": [ + { + "name": "var1", + "nativeSrc": "41525:4:0", + "nodeType": "YulIdentifier", + "src": "41525:4:0" + }, + { + "name": "var2", + "nativeSrc": "41531:4:0", + "nodeType": "YulIdentifier", + "src": "41531:4:0" + }, + { + "name": "r", + "nativeSrc": "41537:1:0", + "nodeType": "YulIdentifier", + "src": "41537:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "41518:6:0", + "nodeType": "YulIdentifier", + "src": "41518:6:0" + }, + "nativeSrc": "41518:21:0", + "nodeType": "YulFunctionCall", + "src": "41518:21:0" + }, + "variables": [ + { + "name": "var3", + "nativeSrc": "41510:4:0", + "nodeType": "YulTypedName", + "src": "41510:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "41564:32:0", + "nodeType": "YulVariableDeclaration", + "src": "41564:32:0", + "value": { + "arguments": [ + { + "name": "var3", + "nativeSrc": "41583:4:0", + "nodeType": "YulIdentifier", + "src": "41583:4:0" + }, + { + "kind": "number", + "nativeSrc": "41589:3:0", + "nodeType": "YulLiteral", + "src": "41589:3:0", + "type": "", + "value": "0x0" + }, + { + "name": "r", + "nativeSrc": "41594:1:0", + "nodeType": "YulIdentifier", + "src": "41594:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "41576:6:0", + "nodeType": "YulIdentifier", + "src": "41576:6:0" + }, + "nativeSrc": "41576:20:0", + "nodeType": "YulFunctionCall", + "src": "41576:20:0" + }, + "variables": [ + { + "name": "var4", + "nativeSrc": "41568:4:0", + "nodeType": "YulTypedName", + "src": "41568:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "41621:33:0", + "nodeType": "YulVariableDeclaration", + "src": "41621:33:0", + "value": { + "arguments": [ + { + "name": "var0", + "nativeSrc": "41640:4:0", + "nodeType": "YulIdentifier", + "src": "41640:4:0" + }, + { + "name": "var4", + "nativeSrc": "41646:4:0", + "nodeType": "YulIdentifier", + "src": "41646:4:0" + }, + { + "name": "r", + "nativeSrc": "41652:1:0", + "nodeType": "YulIdentifier", + "src": "41652:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "41633:6:0", + "nodeType": "YulIdentifier", + "src": "41633:6:0" + }, + "nativeSrc": "41633:21:0", + "nodeType": "YulFunctionCall", + "src": "41633:21:0" + }, + "variables": [ + { + "name": "var5", + "nativeSrc": "41625:4:0", + "nodeType": "YulTypedName", + "src": "41625:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "41679:31:0", + "nodeType": "YulVariableDeclaration", + "src": "41679:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "41703:6:0", + "nodeType": "YulLiteral", + "src": "41703:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "41690:12:0", + "nodeType": "YulIdentifier", + "src": "41690:12:0" + }, + "nativeSrc": "41690:20:0", + "nodeType": "YulFunctionCall", + "src": "41690:20:0" + }, + "variables": [ + { + "name": "a_1", + "nativeSrc": "41683:3:0", + "nodeType": "YulTypedName", + "src": "41683:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "41735:31:0", + "nodeType": "YulVariableDeclaration", + "src": "41735:31:0", + "value": { + "arguments": [ + { + "name": "f_6", + "nativeSrc": "41754:3:0", + "nodeType": "YulIdentifier", + "src": "41754:3:0" + }, + { + "name": "a_1", + "nativeSrc": "41759:3:0", + "nodeType": "YulIdentifier", + "src": "41759:3:0" + }, + { + "name": "r", + "nativeSrc": "41764:1:0", + "nodeType": "YulIdentifier", + "src": "41764:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "41747:6:0", + "nodeType": "YulIdentifier", + "src": "41747:6:0" + }, + "nativeSrc": "41747:19:0", + "nodeType": "YulFunctionCall", + "src": "41747:19:0" + }, + "variables": [ + { + "name": "var6", + "nativeSrc": "41739:4:0", + "nodeType": "YulTypedName", + "src": "41739:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "41791:33:0", + "nodeType": "YulVariableDeclaration", + "src": "41791:33:0", + "value": { + "arguments": [ + { + "name": "var6", + "nativeSrc": "41810:4:0", + "nodeType": "YulIdentifier", + "src": "41810:4:0" + }, + { + "name": "var4", + "nativeSrc": "41816:4:0", + "nodeType": "YulIdentifier", + "src": "41816:4:0" + }, + { + "name": "r", + "nativeSrc": "41822:1:0", + "nodeType": "YulIdentifier", + "src": "41822:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "41803:6:0", + "nodeType": "YulIdentifier", + "src": "41803:6:0" + }, + "nativeSrc": "41803:21:0", + "nodeType": "YulFunctionCall", + "src": "41803:21:0" + }, + "variables": [ + { + "name": "var7", + "nativeSrc": "41795:4:0", + "nodeType": "YulTypedName", + "src": "41795:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "41849:15:0", + "nodeType": "YulAssignment", + "src": "41849:15:0", + "value": { + "name": "var5", + "nativeSrc": "41860:4:0", + "nodeType": "YulIdentifier", + "src": "41860:4:0" + }, + "variableNames": [ + { + "name": "input_0", + "nativeSrc": "41849:7:0", + "nodeType": "YulIdentifier", + "src": "41849:7:0" + } + ] + }, + { + "nativeSrc": "41889:53:0", + "nodeType": "YulAssignment", + "src": "41889:53:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "input_0", + "nativeSrc": "41914:7:0", + "nodeType": "YulIdentifier", + "src": "41914:7:0" + }, + { + "name": "theta", + "nativeSrc": "41923:5:0", + "nodeType": "YulIdentifier", + "src": "41923:5:0" + }, + { + "name": "r", + "nativeSrc": "41930:1:0", + "nodeType": "YulIdentifier", + "src": "41930:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "41907:6:0", + "nodeType": "YulIdentifier", + "src": "41907:6:0" + }, + "nativeSrc": "41907:25:0", + "nodeType": "YulFunctionCall", + "src": "41907:25:0" + }, + { + "name": "var7", + "nativeSrc": "41934:4:0", + "nodeType": "YulIdentifier", + "src": "41934:4:0" + }, + { + "name": "r", + "nativeSrc": "41940:1:0", + "nodeType": "YulIdentifier", + "src": "41940:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "41900:6:0", + "nodeType": "YulIdentifier", + "src": "41900:6:0" + }, + "nativeSrc": "41900:42:0", + "nodeType": "YulFunctionCall", + "src": "41900:42:0" + }, + "variableNames": [ + { + "name": "input_0", + "nativeSrc": "41889:7:0", + "nodeType": "YulIdentifier", + "src": "41889:7:0" + } + ] + }, + { + "nativeSrc": "41967:35:0", + "nodeType": "YulAssignment", + "src": "41967:35:0", + "value": { + "arguments": [ + { + "name": "input_0", + "nativeSrc": "41985:7:0", + "nodeType": "YulIdentifier", + "src": "41985:7:0" + }, + { + "name": "beta", + "nativeSrc": "41994:4:0", + "nodeType": "YulIdentifier", + "src": "41994:4:0" + }, + { + "name": "r", + "nativeSrc": "42000:1:0", + "nodeType": "YulIdentifier", + "src": "42000:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "41978:6:0", + "nodeType": "YulIdentifier", + "src": "41978:6:0" + }, + "nativeSrc": "41978:24:0", + "nodeType": "YulFunctionCall", + "src": "41978:24:0" + }, + "variableNames": [ + { + "name": "input_0", + "nativeSrc": "41967:7:0", + "nodeType": "YulIdentifier", + "src": "41967:7:0" + } + ] + } + ] + }, + { + "nativeSrc": "42045:7:0", + "nodeType": "YulVariableDeclaration", + "src": "42045:7:0", + "variables": [ + { + "name": "lhs", + "nativeSrc": "42049:3:0", + "nodeType": "YulTypedName", + "src": "42049:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "42073:7:0", + "nodeType": "YulVariableDeclaration", + "src": "42073:7:0", + "variables": [ + { + "name": "rhs", + "nativeSrc": "42077:3:0", + "nodeType": "YulTypedName", + "src": "42077:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "42101:12:0", + "nodeType": "YulAssignment", + "src": "42101:12:0", + "value": { + "name": "table", + "nativeSrc": "42108:5:0", + "nodeType": "YulIdentifier", + "src": "42108:5:0" + }, + "variableNames": [ + { + "name": "rhs", + "nativeSrc": "42101:3:0", + "nodeType": "YulIdentifier", + "src": "42101:3:0" + } + ] + }, + { + "nativeSrc": "42134:285:0", + "nodeType": "YulBlock", + "src": "42134:285:0", + "statements": [ + { + "nativeSrc": "42160:18:0", + "nodeType": "YulVariableDeclaration", + "src": "42160:18:0", + "value": { + "name": "input_0", + "nativeSrc": "42171:7:0", + "nodeType": "YulIdentifier", + "src": "42171:7:0" + }, + "variables": [ + { + "name": "tmp", + "nativeSrc": "42164:3:0", + "nodeType": "YulTypedName", + "src": "42164:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "42203:67:0", + "nodeType": "YulAssignment", + "src": "42203:67:0", + "value": { + "arguments": [ + { + "name": "rhs", + "nativeSrc": "42217:3:0", + "nodeType": "YulIdentifier", + "src": "42217:3:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "42226:1:0", + "nodeType": "YulIdentifier", + "src": "42226:1:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "42249:6:0", + "nodeType": "YulLiteral", + "src": "42249:6:0", + "type": "", + "value": "0x0864" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "42236:12:0", + "nodeType": "YulIdentifier", + "src": "42236:12:0" + }, + "nativeSrc": "42236:20:0", + "nodeType": "YulFunctionCall", + "src": "42236:20:0" + }, + { + "name": "tmp", + "nativeSrc": "42258:3:0", + "nodeType": "YulIdentifier", + "src": "42258:3:0" + }, + { + "name": "r", + "nativeSrc": "42263:1:0", + "nodeType": "YulIdentifier", + "src": "42263:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "42229:6:0", + "nodeType": "YulIdentifier", + "src": "42229:6:0" + }, + "nativeSrc": "42229:36:0", + "nodeType": "YulFunctionCall", + "src": "42229:36:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "42222:3:0", + "nodeType": "YulIdentifier", + "src": "42222:3:0" + }, + "nativeSrc": "42222:44:0", + "nodeType": "YulFunctionCall", + "src": "42222:44:0" + }, + { + "name": "r", + "nativeSrc": "42268:1:0", + "nodeType": "YulIdentifier", + "src": "42268:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "42210:6:0", + "nodeType": "YulIdentifier", + "src": "42210:6:0" + }, + "nativeSrc": "42210:60:0", + "nodeType": "YulFunctionCall", + "src": "42210:60:0" + }, + "variableNames": [ + { + "name": "rhs", + "nativeSrc": "42203:3:0", + "nodeType": "YulIdentifier", + "src": "42203:3:0" + } + ] + }, + { + "nativeSrc": "42295:102:0", + "nodeType": "YulAssignment", + "src": "42295:102:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "table", + "nativeSrc": "42316:5:0", + "nodeType": "YulIdentifier", + "src": "42316:5:0" + }, + { + "name": "tmp", + "nativeSrc": "42323:3:0", + "nodeType": "YulIdentifier", + "src": "42323:3:0" + }, + { + "name": "r", + "nativeSrc": "42328:1:0", + "nodeType": "YulIdentifier", + "src": "42328:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "42309:6:0", + "nodeType": "YulIdentifier", + "src": "42309:6:0" + }, + "nativeSrc": "42309:21:0", + "nodeType": "YulFunctionCall", + "src": "42309:21:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "42352:6:0", + "nodeType": "YulLiteral", + "src": "42352:6:0", + "type": "", + "value": "0x0844" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "42339:12:0", + "nodeType": "YulIdentifier", + "src": "42339:12:0" + }, + "nativeSrc": "42339:20:0", + "nodeType": "YulFunctionCall", + "src": "42339:20:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "42365:1:0", + "nodeType": "YulIdentifier", + "src": "42365:1:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "42381:6:0", + "nodeType": "YulLiteral", + "src": "42381:6:0", + "type": "", + "value": "0x0824" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "42368:12:0", + "nodeType": "YulIdentifier", + "src": "42368:12:0" + }, + "nativeSrc": "42368:20:0", + "nodeType": "YulFunctionCall", + "src": "42368:20:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "42361:3:0", + "nodeType": "YulIdentifier", + "src": "42361:3:0" + }, + "nativeSrc": "42361:28:0", + "nodeType": "YulFunctionCall", + "src": "42361:28:0" + }, + { + "name": "r", + "nativeSrc": "42391:1:0", + "nodeType": "YulIdentifier", + "src": "42391:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "42332:6:0", + "nodeType": "YulIdentifier", + "src": "42332:6:0" + }, + "nativeSrc": "42332:61:0", + "nodeType": "YulFunctionCall", + "src": "42332:61:0" + }, + { + "name": "r", + "nativeSrc": "42395:1:0", + "nodeType": "YulIdentifier", + "src": "42395:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "42302:6:0", + "nodeType": "YulIdentifier", + "src": "42302:6:0" + }, + "nativeSrc": "42302:95:0", + "nodeType": "YulFunctionCall", + "src": "42302:95:0" + }, + "variableNames": [ + { + "name": "lhs", + "nativeSrc": "42295:3:0", + "nodeType": "YulIdentifier", + "src": "42295:3:0" + } + ] + } + ] + }, + { + "nativeSrc": "42440:124:0", + "nodeType": "YulVariableDeclaration", + "src": "42440:124:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "42466:1:0", + "nodeType": "YulLiteral", + "src": "42466:1:0", + "type": "", + "value": "1" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "42473:1:0", + "nodeType": "YulIdentifier", + "src": "42473:1:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "L_BLIND_MPTR", + "nativeSrc": "42489:12:0", + "nodeType": "YulIdentifier", + "src": "42489:12:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "42483:5:0", + "nodeType": "YulIdentifier", + "src": "42483:5:0" + }, + "nativeSrc": "42483:19:0", + "nodeType": "YulFunctionCall", + "src": "42483:19:0" + }, + { + "arguments": [ + { + "name": "L_LAST_MPTR", + "nativeSrc": "42510:11:0", + "nodeType": "YulIdentifier", + "src": "42510:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "42504:5:0", + "nodeType": "YulIdentifier", + "src": "42504:5:0" + }, + "nativeSrc": "42504:18:0", + "nodeType": "YulFunctionCall", + "src": "42504:18:0" + }, + { + "name": "r", + "nativeSrc": "42524:1:0", + "nodeType": "YulIdentifier", + "src": "42524:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "42476:6:0", + "nodeType": "YulIdentifier", + "src": "42476:6:0" + }, + "nativeSrc": "42476:50:0", + "nodeType": "YulFunctionCall", + "src": "42476:50:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "42469:3:0", + "nodeType": "YulIdentifier", + "src": "42469:3:0" + }, + "nativeSrc": "42469:58:0", + "nodeType": "YulFunctionCall", + "src": "42469:58:0" + }, + { + "name": "r", + "nativeSrc": "42529:1:0", + "nodeType": "YulIdentifier", + "src": "42529:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "42459:6:0", + "nodeType": "YulIdentifier", + "src": "42459:6:0" + }, + "nativeSrc": "42459:72:0", + "nodeType": "YulFunctionCall", + "src": "42459:72:0" + }, + { + "arguments": [ + { + "name": "lhs", + "nativeSrc": "42540:3:0", + "nodeType": "YulIdentifier", + "src": "42540:3:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "42549:1:0", + "nodeType": "YulIdentifier", + "src": "42549:1:0" + }, + { + "name": "rhs", + "nativeSrc": "42552:3:0", + "nodeType": "YulIdentifier", + "src": "42552:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "42545:3:0", + "nodeType": "YulIdentifier", + "src": "42545:3:0" + }, + "nativeSrc": "42545:11:0", + "nodeType": "YulFunctionCall", + "src": "42545:11:0" + }, + { + "name": "r", + "nativeSrc": "42558:1:0", + "nodeType": "YulIdentifier", + "src": "42558:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "42533:6:0", + "nodeType": "YulIdentifier", + "src": "42533:6:0" + }, + "nativeSrc": "42533:27:0", + "nodeType": "YulFunctionCall", + "src": "42533:27:0" + }, + { + "name": "r", + "nativeSrc": "42562:1:0", + "nodeType": "YulIdentifier", + "src": "42562:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "42452:6:0", + "nodeType": "YulIdentifier", + "src": "42452:6:0" + }, + "nativeSrc": "42452:112:0", + "nodeType": "YulFunctionCall", + "src": "42452:112:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "42444:4:0", + "nodeType": "YulTypedName", + "src": "42444:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "42585:73:0", + "nodeType": "YulAssignment", + "src": "42585:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "42622:19:0", + "nodeType": "YulIdentifier", + "src": "42622:19:0" + }, + { + "name": "y", + "nativeSrc": "42643:1:0", + "nodeType": "YulIdentifier", + "src": "42643:1:0" + }, + { + "name": "r", + "nativeSrc": "42646:1:0", + "nodeType": "YulIdentifier", + "src": "42646:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "42615:6:0", + "nodeType": "YulIdentifier", + "src": "42615:6:0" + }, + "nativeSrc": "42615:33:0", + "nodeType": "YulFunctionCall", + "src": "42615:33:0" + }, + { + "name": "eval", + "nativeSrc": "42650:4:0", + "nodeType": "YulIdentifier", + "src": "42650:4:0" + }, + { + "name": "r", + "nativeSrc": "42656:1:0", + "nodeType": "YulIdentifier", + "src": "42656:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "42608:6:0", + "nodeType": "YulIdentifier", + "src": "42608:6:0" + }, + "nativeSrc": "42608:50:0", + "nodeType": "YulFunctionCall", + "src": "42608:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "42585:19:0", + "nodeType": "YulIdentifier", + "src": "42585:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "42693:229:0", + "nodeType": "YulBlock", + "src": "42693:229:0", + "statements": [ + { + "nativeSrc": "42715:26:0", + "nodeType": "YulVariableDeclaration", + "src": "42715:26:0", + "value": { + "arguments": [ + { + "name": "L_0_MPTR", + "nativeSrc": "42732:8:0", + "nodeType": "YulIdentifier", + "src": "42732:8:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "42726:5:0", + "nodeType": "YulIdentifier", + "src": "42726:5:0" + }, + "nativeSrc": "42726:15:0", + "nodeType": "YulFunctionCall", + "src": "42726:15:0" + }, + "variables": [ + { + "name": "l_0", + "nativeSrc": "42719:3:0", + "nodeType": "YulTypedName", + "src": "42719:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "42762:48:0", + "nodeType": "YulVariableDeclaration", + "src": "42762:48:0", + "value": { + "arguments": [ + { + "name": "l_0", + "nativeSrc": "42781:3:0", + "nodeType": "YulIdentifier", + "src": "42781:3:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "42799:6:0", + "nodeType": "YulLiteral", + "src": "42799:6:0", + "type": "", + "value": "0x0884" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "42786:12:0", + "nodeType": "YulIdentifier", + "src": "42786:12:0" + }, + "nativeSrc": "42786:20:0", + "nodeType": "YulFunctionCall", + "src": "42786:20:0" + }, + { + "name": "r", + "nativeSrc": "42808:1:0", + "nodeType": "YulIdentifier", + "src": "42808:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "42774:6:0", + "nodeType": "YulIdentifier", + "src": "42774:6:0" + }, + "nativeSrc": "42774:36:0", + "nodeType": "YulFunctionCall", + "src": "42774:36:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "42766:4:0", + "nodeType": "YulTypedName", + "src": "42766:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "42831:73:0", + "nodeType": "YulAssignment", + "src": "42831:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "42868:19:0", + "nodeType": "YulIdentifier", + "src": "42868:19:0" + }, + { + "name": "y", + "nativeSrc": "42889:1:0", + "nodeType": "YulIdentifier", + "src": "42889:1:0" + }, + { + "name": "r", + "nativeSrc": "42892:1:0", + "nodeType": "YulIdentifier", + "src": "42892:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "42861:6:0", + "nodeType": "YulIdentifier", + "src": "42861:6:0" + }, + "nativeSrc": "42861:33:0", + "nodeType": "YulFunctionCall", + "src": "42861:33:0" + }, + { + "name": "eval", + "nativeSrc": "42896:4:0", + "nodeType": "YulIdentifier", + "src": "42896:4:0" + }, + { + "name": "r", + "nativeSrc": "42902:1:0", + "nodeType": "YulIdentifier", + "src": "42902:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "42854:6:0", + "nodeType": "YulIdentifier", + "src": "42854:6:0" + }, + "nativeSrc": "42854:50:0", + "nodeType": "YulFunctionCall", + "src": "42854:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "42831:19:0", + "nodeType": "YulIdentifier", + "src": "42831:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "42939:238:0", + "nodeType": "YulBlock", + "src": "42939:238:0", + "statements": [ + { + "nativeSrc": "42961:32:0", + "nodeType": "YulVariableDeclaration", + "src": "42961:32:0", + "value": { + "arguments": [ + { + "name": "L_LAST_MPTR", + "nativeSrc": "42981:11:0", + "nodeType": "YulIdentifier", + "src": "42981:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "42975:5:0", + "nodeType": "YulIdentifier", + "src": "42975:5:0" + }, + "nativeSrc": "42975:18:0", + "nodeType": "YulFunctionCall", + "src": "42975:18:0" + }, + "variables": [ + { + "name": "l_last", + "nativeSrc": "42965:6:0", + "nodeType": "YulTypedName", + "src": "42965:6:0", + "type": "" + } + ] + }, + { + "nativeSrc": "43014:51:0", + "nodeType": "YulVariableDeclaration", + "src": "43014:51:0", + "value": { + "arguments": [ + { + "name": "l_last", + "nativeSrc": "43033:6:0", + "nodeType": "YulIdentifier", + "src": "43033:6:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "43054:6:0", + "nodeType": "YulLiteral", + "src": "43054:6:0", + "type": "", + "value": "0x0884" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "43041:12:0", + "nodeType": "YulIdentifier", + "src": "43041:12:0" + }, + "nativeSrc": "43041:20:0", + "nodeType": "YulFunctionCall", + "src": "43041:20:0" + }, + { + "name": "r", + "nativeSrc": "43063:1:0", + "nodeType": "YulIdentifier", + "src": "43063:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "43026:6:0", + "nodeType": "YulIdentifier", + "src": "43026:6:0" + }, + "nativeSrc": "43026:39:0", + "nodeType": "YulFunctionCall", + "src": "43026:39:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "43018:4:0", + "nodeType": "YulTypedName", + "src": "43018:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "43086:73:0", + "nodeType": "YulAssignment", + "src": "43086:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "43123:19:0", + "nodeType": "YulIdentifier", + "src": "43123:19:0" + }, + { + "name": "y", + "nativeSrc": "43144:1:0", + "nodeType": "YulIdentifier", + "src": "43144:1:0" + }, + { + "name": "r", + "nativeSrc": "43147:1:0", + "nodeType": "YulIdentifier", + "src": "43147:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "43116:6:0", + "nodeType": "YulIdentifier", + "src": "43116:6:0" + }, + "nativeSrc": "43116:33:0", + "nodeType": "YulFunctionCall", + "src": "43116:33:0" + }, + { + "name": "eval", + "nativeSrc": "43151:4:0", + "nodeType": "YulIdentifier", + "src": "43151:4:0" + }, + { + "name": "r", + "nativeSrc": "43157:1:0", + "nodeType": "YulIdentifier", + "src": "43157:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "43109:6:0", + "nodeType": "YulIdentifier", + "src": "43109:6:0" + }, + "nativeSrc": "43109:50:0", + "nodeType": "YulFunctionCall", + "src": "43109:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "43086:19:0", + "nodeType": "YulIdentifier", + "src": "43086:19:0" + } + ] + } + ] + }, + { + "nativeSrc": "43194:2015:0", + "nodeType": "YulBlock", + "src": "43194:2015:0", + "statements": [ + { + "nativeSrc": "43216:30:0", + "nodeType": "YulVariableDeclaration", + "src": "43216:30:0", + "value": { + "arguments": [ + { + "name": "THETA_MPTR", + "nativeSrc": "43235:10:0", + "nodeType": "YulIdentifier", + "src": "43235:10:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "43229:5:0", + "nodeType": "YulIdentifier", + "src": "43229:5:0" + }, + "nativeSrc": "43229:17:0", + "nodeType": "YulFunctionCall", + "src": "43229:17:0" + }, + "variables": [ + { + "name": "theta", + "nativeSrc": "43220:5:0", + "nodeType": "YulTypedName", + "src": "43220:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "43267:28:0", + "nodeType": "YulVariableDeclaration", + "src": "43267:28:0", + "value": { + "arguments": [ + { + "name": "BETA_MPTR", + "nativeSrc": "43285:9:0", + "nodeType": "YulIdentifier", + "src": "43285:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "43279:5:0", + "nodeType": "YulIdentifier", + "src": "43279:5:0" + }, + "nativeSrc": "43279:16:0", + "nodeType": "YulFunctionCall", + "src": "43279:16:0" + }, + "variables": [ + { + "name": "beta", + "nativeSrc": "43271:4:0", + "nodeType": "YulTypedName", + "src": "43271:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "43316:9:0", + "nodeType": "YulVariableDeclaration", + "src": "43316:9:0", + "variables": [ + { + "name": "table", + "nativeSrc": "43320:5:0", + "nodeType": "YulTypedName", + "src": "43320:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "43346:301:0", + "nodeType": "YulBlock", + "src": "43346:301:0", + "statements": [ + { + "nativeSrc": "43372:31:0", + "nodeType": "YulVariableDeclaration", + "src": "43372:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "43396:6:0", + "nodeType": "YulLiteral", + "src": "43396:6:0", + "type": "", + "value": "0x0504" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "43383:12:0", + "nodeType": "YulIdentifier", + "src": "43383:12:0" + }, + "nativeSrc": "43383:20:0", + "nodeType": "YulFunctionCall", + "src": "43383:20:0" + }, + "variables": [ + { + "name": "f_1", + "nativeSrc": "43376:3:0", + "nodeType": "YulTypedName", + "src": "43376:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "43428:31:0", + "nodeType": "YulVariableDeclaration", + "src": "43428:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "43452:6:0", + "nodeType": "YulLiteral", + "src": "43452:6:0", + "type": "", + "value": "0x0564" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "43439:12:0", + "nodeType": "YulIdentifier", + "src": "43439:12:0" + }, + "nativeSrc": "43439:20:0", + "nodeType": "YulFunctionCall", + "src": "43439:20:0" + }, + "variables": [ + { + "name": "f_4", + "nativeSrc": "43432:3:0", + "nodeType": "YulTypedName", + "src": "43432:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "43484:12:0", + "nodeType": "YulAssignment", + "src": "43484:12:0", + "value": { + "name": "f_1", + "nativeSrc": "43493:3:0", + "nodeType": "YulIdentifier", + "src": "43493:3:0" + }, + "variableNames": [ + { + "name": "table", + "nativeSrc": "43484:5:0", + "nodeType": "YulIdentifier", + "src": "43484:5:0" + } + ] + }, + { + "nativeSrc": "43521:48:0", + "nodeType": "YulAssignment", + "src": "43521:48:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "table", + "nativeSrc": "43544:5:0", + "nodeType": "YulIdentifier", + "src": "43544:5:0" + }, + { + "name": "theta", + "nativeSrc": "43551:5:0", + "nodeType": "YulIdentifier", + "src": "43551:5:0" + }, + { + "name": "r", + "nativeSrc": "43558:1:0", + "nodeType": "YulIdentifier", + "src": "43558:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "43537:6:0", + "nodeType": "YulIdentifier", + "src": "43537:6:0" + }, + "nativeSrc": "43537:23:0", + "nodeType": "YulFunctionCall", + "src": "43537:23:0" + }, + { + "name": "f_4", + "nativeSrc": "43562:3:0", + "nodeType": "YulIdentifier", + "src": "43562:3:0" + }, + { + "name": "r", + "nativeSrc": "43567:1:0", + "nodeType": "YulIdentifier", + "src": "43567:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "43530:6:0", + "nodeType": "YulIdentifier", + "src": "43530:6:0" + }, + "nativeSrc": "43530:39:0", + "nodeType": "YulFunctionCall", + "src": "43530:39:0" + }, + "variableNames": [ + { + "name": "table", + "nativeSrc": "43521:5:0", + "nodeType": "YulIdentifier", + "src": "43521:5:0" + } + ] + }, + { + "nativeSrc": "43594:31:0", + "nodeType": "YulAssignment", + "src": "43594:31:0", + "value": { + "arguments": [ + { + "name": "table", + "nativeSrc": "43610:5:0", + "nodeType": "YulIdentifier", + "src": "43610:5:0" + }, + { + "name": "beta", + "nativeSrc": "43617:4:0", + "nodeType": "YulIdentifier", + "src": "43617:4:0" + }, + { + "name": "r", + "nativeSrc": "43623:1:0", + "nodeType": "YulIdentifier", + "src": "43623:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "43603:6:0", + "nodeType": "YulIdentifier", + "src": "43603:6:0" + }, + "nativeSrc": "43603:22:0", + "nodeType": "YulFunctionCall", + "src": "43603:22:0" + }, + "variableNames": [ + { + "name": "table", + "nativeSrc": "43594:5:0", + "nodeType": "YulIdentifier", + "src": "43594:5:0" + } + ] + } + ] + }, + { + "nativeSrc": "43668:11:0", + "nodeType": "YulVariableDeclaration", + "src": "43668:11:0", + "variables": [ + { + "name": "input_0", + "nativeSrc": "43672:7:0", + "nodeType": "YulTypedName", + "src": "43672:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "43700:857:0", + "nodeType": "YulBlock", + "src": "43700:857:0", + "statements": [ + { + "nativeSrc": "43726:31:0", + "nodeType": "YulVariableDeclaration", + "src": "43726:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "43750:6:0", + "nodeType": "YulLiteral", + "src": "43750:6:0", + "type": "", + "value": "0x05c4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "43737:12:0", + "nodeType": "YulIdentifier", + "src": "43737:12:0" + }, + "nativeSrc": "43737:20:0", + "nodeType": "YulFunctionCall", + "src": "43737:20:0" + }, + "variables": [ + { + "name": "f_7", + "nativeSrc": "43730:3:0", + "nodeType": "YulTypedName", + "src": "43730:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "43782:31:0", + "nodeType": "YulVariableDeclaration", + "src": "43782:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "43806:6:0", + "nodeType": "YulLiteral", + "src": "43806:6:0", + "type": "", + "value": "0x0464" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "43793:12:0", + "nodeType": "YulIdentifier", + "src": "43793:12:0" + }, + "nativeSrc": "43793:20:0", + "nodeType": "YulFunctionCall", + "src": "43793:20:0" + }, + "variables": [ + { + "name": "a_0", + "nativeSrc": "43786:3:0", + "nodeType": "YulTypedName", + "src": "43786:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "43838:31:0", + "nodeType": "YulVariableDeclaration", + "src": "43838:31:0", + "value": { + "arguments": [ + { + "name": "f_7", + "nativeSrc": "43857:3:0", + "nodeType": "YulIdentifier", + "src": "43857:3:0" + }, + { + "name": "a_0", + "nativeSrc": "43862:3:0", + "nodeType": "YulIdentifier", + "src": "43862:3:0" + }, + { + "name": "r", + "nativeSrc": "43867:1:0", + "nodeType": "YulIdentifier", + "src": "43867:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "43850:6:0", + "nodeType": "YulIdentifier", + "src": "43850:6:0" + }, + "nativeSrc": "43850:19:0", + "nodeType": "YulFunctionCall", + "src": "43850:19:0" + }, + "variables": [ + { + "name": "var0", + "nativeSrc": "43842:4:0", + "nodeType": "YulTypedName", + "src": "43842:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "43894:15:0", + "nodeType": "YulVariableDeclaration", + "src": "43894:15:0", + "value": { + "kind": "number", + "nativeSrc": "43906:3:0", + "nodeType": "YulLiteral", + "src": "43906:3:0", + "type": "", + "value": "0x1" + }, + "variables": [ + { + "name": "var1", + "nativeSrc": "43898:4:0", + "nodeType": "YulTypedName", + "src": "43898:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "43934:23:0", + "nodeType": "YulVariableDeclaration", + "src": "43934:23:0", + "value": { + "arguments": [ + { + "name": "r", + "nativeSrc": "43950:1:0", + "nodeType": "YulIdentifier", + "src": "43950:1:0" + }, + { + "name": "f_7", + "nativeSrc": "43953:3:0", + "nodeType": "YulIdentifier", + "src": "43953:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "43946:3:0", + "nodeType": "YulIdentifier", + "src": "43946:3:0" + }, + "nativeSrc": "43946:11:0", + "nodeType": "YulFunctionCall", + "src": "43946:11:0" + }, + "variables": [ + { + "name": "var2", + "nativeSrc": "43938:4:0", + "nodeType": "YulTypedName", + "src": "43938:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "43982:33:0", + "nodeType": "YulVariableDeclaration", + "src": "43982:33:0", + "value": { + "arguments": [ + { + "name": "var1", + "nativeSrc": "44001:4:0", + "nodeType": "YulIdentifier", + "src": "44001:4:0" + }, + { + "name": "var2", + "nativeSrc": "44007:4:0", + "nodeType": "YulIdentifier", + "src": "44007:4:0" + }, + { + "name": "r", + "nativeSrc": "44013:1:0", + "nodeType": "YulIdentifier", + "src": "44013:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "43994:6:0", + "nodeType": "YulIdentifier", + "src": "43994:6:0" + }, + "nativeSrc": "43994:21:0", + "nodeType": "YulFunctionCall", + "src": "43994:21:0" + }, + "variables": [ + { + "name": "var3", + "nativeSrc": "43986:4:0", + "nodeType": "YulTypedName", + "src": "43986:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "44040:32:0", + "nodeType": "YulVariableDeclaration", + "src": "44040:32:0", + "value": { + "arguments": [ + { + "name": "var3", + "nativeSrc": "44059:4:0", + "nodeType": "YulIdentifier", + "src": "44059:4:0" + }, + { + "kind": "number", + "nativeSrc": "44065:3:0", + "nodeType": "YulLiteral", + "src": "44065:3:0", + "type": "", + "value": "0x0" + }, + { + "name": "r", + "nativeSrc": "44070:1:0", + "nodeType": "YulIdentifier", + "src": "44070:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "44052:6:0", + "nodeType": "YulIdentifier", + "src": "44052:6:0" + }, + "nativeSrc": "44052:20:0", + "nodeType": "YulFunctionCall", + "src": "44052:20:0" + }, + "variables": [ + { + "name": "var4", + "nativeSrc": "44044:4:0", + "nodeType": "YulTypedName", + "src": "44044:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "44097:33:0", + "nodeType": "YulVariableDeclaration", + "src": "44097:33:0", + "value": { + "arguments": [ + { + "name": "var0", + "nativeSrc": "44116:4:0", + "nodeType": "YulIdentifier", + "src": "44116:4:0" + }, + { + "name": "var4", + "nativeSrc": "44122:4:0", + "nodeType": "YulIdentifier", + "src": "44122:4:0" + }, + { + "name": "r", + "nativeSrc": "44128:1:0", + "nodeType": "YulIdentifier", + "src": "44128:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "44109:6:0", + "nodeType": "YulIdentifier", + "src": "44109:6:0" + }, + "nativeSrc": "44109:21:0", + "nodeType": "YulFunctionCall", + "src": "44109:21:0" + }, + "variables": [ + { + "name": "var5", + "nativeSrc": "44101:4:0", + "nodeType": "YulTypedName", + "src": "44101:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "44155:31:0", + "nodeType": "YulVariableDeclaration", + "src": "44155:31:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "44179:6:0", + "nodeType": "YulLiteral", + "src": "44179:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "44166:12:0", + "nodeType": "YulIdentifier", + "src": "44166:12:0" + }, + "nativeSrc": "44166:20:0", + "nodeType": "YulFunctionCall", + "src": "44166:20:0" + }, + "variables": [ + { + "name": "a_1", + "nativeSrc": "44159:3:0", + "nodeType": "YulTypedName", + "src": "44159:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "44211:31:0", + "nodeType": "YulVariableDeclaration", + "src": "44211:31:0", + "value": { + "arguments": [ + { + "name": "f_7", + "nativeSrc": "44230:3:0", + "nodeType": "YulIdentifier", + "src": "44230:3:0" + }, + { + "name": "a_1", + "nativeSrc": "44235:3:0", + "nodeType": "YulIdentifier", + "src": "44235:3:0" + }, + { + "name": "r", + "nativeSrc": "44240:1:0", + "nodeType": "YulIdentifier", + "src": "44240:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "44223:6:0", + "nodeType": "YulIdentifier", + "src": "44223:6:0" + }, + "nativeSrc": "44223:19:0", + "nodeType": "YulFunctionCall", + "src": "44223:19:0" + }, + "variables": [ + { + "name": "var6", + "nativeSrc": "44215:4:0", + "nodeType": "YulTypedName", + "src": "44215:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "44267:32:0", + "nodeType": "YulVariableDeclaration", + "src": "44267:32:0", + "value": { + "arguments": [ + { + "name": "var3", + "nativeSrc": "44286:4:0", + "nodeType": "YulIdentifier", + "src": "44286:4:0" + }, + { + "kind": "number", + "nativeSrc": "44292:3:0", + "nodeType": "YulLiteral", + "src": "44292:3:0", + "type": "", + "value": "0x1" + }, + { + "name": "r", + "nativeSrc": "44297:1:0", + "nodeType": "YulIdentifier", + "src": "44297:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "44279:6:0", + "nodeType": "YulIdentifier", + "src": "44279:6:0" + }, + "nativeSrc": "44279:20:0", + "nodeType": "YulFunctionCall", + "src": "44279:20:0" + }, + "variables": [ + { + "name": "var7", + "nativeSrc": "44271:4:0", + "nodeType": "YulTypedName", + "src": "44271:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "44324:33:0", + "nodeType": "YulVariableDeclaration", + "src": "44324:33:0", + "value": { + "arguments": [ + { + "name": "var6", + "nativeSrc": "44343:4:0", + "nodeType": "YulIdentifier", + "src": "44343:4:0" + }, + { + "name": "var7", + "nativeSrc": "44349:4:0", + "nodeType": "YulIdentifier", + "src": "44349:4:0" + }, + { + "name": "r", + "nativeSrc": "44355:1:0", + "nodeType": "YulIdentifier", + "src": "44355:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "44336:6:0", + "nodeType": "YulIdentifier", + "src": "44336:6:0" + }, + "nativeSrc": "44336:21:0", + "nodeType": "YulFunctionCall", + "src": "44336:21:0" + }, + "variables": [ + { + "name": "var8", + "nativeSrc": "44328:4:0", + "nodeType": "YulTypedName", + "src": "44328:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "44382:15:0", + "nodeType": "YulAssignment", + "src": "44382:15:0", + "value": { + "name": "var5", + "nativeSrc": "44393:4:0", + "nodeType": "YulIdentifier", + "src": "44393:4:0" + }, + "variableNames": [ + { + "name": "input_0", + "nativeSrc": "44382:7:0", + "nodeType": "YulIdentifier", + "src": "44382:7:0" + } + ] + }, + { + "nativeSrc": "44422:53:0", + "nodeType": "YulAssignment", + "src": "44422:53:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "input_0", + "nativeSrc": "44447:7:0", + "nodeType": "YulIdentifier", + "src": "44447:7:0" + }, + { + "name": "theta", + "nativeSrc": "44456:5:0", + "nodeType": "YulIdentifier", + "src": "44456:5:0" + }, + { + "name": "r", + "nativeSrc": "44463:1:0", + "nodeType": "YulIdentifier", + "src": "44463:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "44440:6:0", + "nodeType": "YulIdentifier", + "src": "44440:6:0" + }, + "nativeSrc": "44440:25:0", + "nodeType": "YulFunctionCall", + "src": "44440:25:0" + }, + { + "name": "var8", + "nativeSrc": "44467:4:0", + "nodeType": "YulIdentifier", + "src": "44467:4:0" + }, + { + "name": "r", + "nativeSrc": "44473:1:0", + "nodeType": "YulIdentifier", + "src": "44473:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "44433:6:0", + "nodeType": "YulIdentifier", + "src": "44433:6:0" + }, + "nativeSrc": "44433:42:0", + "nodeType": "YulFunctionCall", + "src": "44433:42:0" + }, + "variableNames": [ + { + "name": "input_0", + "nativeSrc": "44422:7:0", + "nodeType": "YulIdentifier", + "src": "44422:7:0" + } + ] + }, + { + "nativeSrc": "44500:35:0", + "nodeType": "YulAssignment", + "src": "44500:35:0", + "value": { + "arguments": [ + { + "name": "input_0", + "nativeSrc": "44518:7:0", + "nodeType": "YulIdentifier", + "src": "44518:7:0" + }, + { + "name": "beta", + "nativeSrc": "44527:4:0", + "nodeType": "YulIdentifier", + "src": "44527:4:0" + }, + { + "name": "r", + "nativeSrc": "44533:1:0", + "nodeType": "YulIdentifier", + "src": "44533:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "44511:6:0", + "nodeType": "YulIdentifier", + "src": "44511:6:0" + }, + "nativeSrc": "44511:24:0", + "nodeType": "YulFunctionCall", + "src": "44511:24:0" + }, + "variableNames": [ + { + "name": "input_0", + "nativeSrc": "44500:7:0", + "nodeType": "YulIdentifier", + "src": "44500:7:0" + } + ] + } + ] + }, + { + "nativeSrc": "44578:7:0", + "nodeType": "YulVariableDeclaration", + "src": "44578:7:0", + "variables": [ + { + "name": "lhs", + "nativeSrc": "44582:3:0", + "nodeType": "YulTypedName", + "src": "44582:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "44606:7:0", + "nodeType": "YulVariableDeclaration", + "src": "44606:7:0", + "variables": [ + { + "name": "rhs", + "nativeSrc": "44610:3:0", + "nodeType": "YulTypedName", + "src": "44610:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "44634:12:0", + "nodeType": "YulAssignment", + "src": "44634:12:0", + "value": { + "name": "table", + "nativeSrc": "44641:5:0", + "nodeType": "YulIdentifier", + "src": "44641:5:0" + }, + "variableNames": [ + { + "name": "rhs", + "nativeSrc": "44634:3:0", + "nodeType": "YulIdentifier", + "src": "44634:3:0" + } + ] + }, + { + "nativeSrc": "44667:285:0", + "nodeType": "YulBlock", + "src": "44667:285:0", + "statements": [ + { + "nativeSrc": "44693:18:0", + "nodeType": "YulVariableDeclaration", + "src": "44693:18:0", + "value": { + "name": "input_0", + "nativeSrc": "44704:7:0", + "nodeType": "YulIdentifier", + "src": "44704:7:0" + }, + "variables": [ + { + "name": "tmp", + "nativeSrc": "44697:3:0", + "nodeType": "YulTypedName", + "src": "44697:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "44736:67:0", + "nodeType": "YulAssignment", + "src": "44736:67:0", + "value": { + "arguments": [ + { + "name": "rhs", + "nativeSrc": "44750:3:0", + "nodeType": "YulIdentifier", + "src": "44750:3:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "44759:1:0", + "nodeType": "YulIdentifier", + "src": "44759:1:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "44782:6:0", + "nodeType": "YulLiteral", + "src": "44782:6:0", + "type": "", + "value": "0x08c4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "44769:12:0", + "nodeType": "YulIdentifier", + "src": "44769:12:0" + }, + "nativeSrc": "44769:20:0", + "nodeType": "YulFunctionCall", + "src": "44769:20:0" + }, + { + "name": "tmp", + "nativeSrc": "44791:3:0", + "nodeType": "YulIdentifier", + "src": "44791:3:0" + }, + { + "name": "r", + "nativeSrc": "44796:1:0", + "nodeType": "YulIdentifier", + "src": "44796:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "44762:6:0", + "nodeType": "YulIdentifier", + "src": "44762:6:0" + }, + "nativeSrc": "44762:36:0", + "nodeType": "YulFunctionCall", + "src": "44762:36:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "44755:3:0", + "nodeType": "YulIdentifier", + "src": "44755:3:0" + }, + "nativeSrc": "44755:44:0", + "nodeType": "YulFunctionCall", + "src": "44755:44:0" + }, + { + "name": "r", + "nativeSrc": "44801:1:0", + "nodeType": "YulIdentifier", + "src": "44801:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "44743:6:0", + "nodeType": "YulIdentifier", + "src": "44743:6:0" + }, + "nativeSrc": "44743:60:0", + "nodeType": "YulFunctionCall", + "src": "44743:60:0" + }, + "variableNames": [ + { + "name": "rhs", + "nativeSrc": "44736:3:0", + "nodeType": "YulIdentifier", + "src": "44736:3:0" + } + ] + }, + { + "nativeSrc": "44828:102:0", + "nodeType": "YulAssignment", + "src": "44828:102:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "table", + "nativeSrc": "44849:5:0", + "nodeType": "YulIdentifier", + "src": "44849:5:0" + }, + { + "name": "tmp", + "nativeSrc": "44856:3:0", + "nodeType": "YulIdentifier", + "src": "44856:3:0" + }, + { + "name": "r", + "nativeSrc": "44861:1:0", + "nodeType": "YulIdentifier", + "src": "44861:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "44842:6:0", + "nodeType": "YulIdentifier", + "src": "44842:6:0" + }, + "nativeSrc": "44842:21:0", + "nodeType": "YulFunctionCall", + "src": "44842:21:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "44885:6:0", + "nodeType": "YulLiteral", + "src": "44885:6:0", + "type": "", + "value": "0x08a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "44872:12:0", + "nodeType": "YulIdentifier", + "src": "44872:12:0" + }, + "nativeSrc": "44872:20:0", + "nodeType": "YulFunctionCall", + "src": "44872:20:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "44898:1:0", + "nodeType": "YulIdentifier", + "src": "44898:1:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "44914:6:0", + "nodeType": "YulLiteral", + "src": "44914:6:0", + "type": "", + "value": "0x0884" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "44901:12:0", + "nodeType": "YulIdentifier", + "src": "44901:12:0" + }, + "nativeSrc": "44901:20:0", + "nodeType": "YulFunctionCall", + "src": "44901:20:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "44894:3:0", + "nodeType": "YulIdentifier", + "src": "44894:3:0" + }, + "nativeSrc": "44894:28:0", + "nodeType": "YulFunctionCall", + "src": "44894:28:0" + }, + { + "name": "r", + "nativeSrc": "44924:1:0", + "nodeType": "YulIdentifier", + "src": "44924:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "44865:6:0", + "nodeType": "YulIdentifier", + "src": "44865:6:0" + }, + "nativeSrc": "44865:61:0", + "nodeType": "YulFunctionCall", + "src": "44865:61:0" + }, + { + "name": "r", + "nativeSrc": "44928:1:0", + "nodeType": "YulIdentifier", + "src": "44928:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "44835:6:0", + "nodeType": "YulIdentifier", + "src": "44835:6:0" + }, + "nativeSrc": "44835:95:0", + "nodeType": "YulFunctionCall", + "src": "44835:95:0" + }, + "variableNames": [ + { + "name": "lhs", + "nativeSrc": "44828:3:0", + "nodeType": "YulIdentifier", + "src": "44828:3:0" + } + ] + } + ] + }, + { + "nativeSrc": "44973:124:0", + "nodeType": "YulVariableDeclaration", + "src": "44973:124:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "44999:1:0", + "nodeType": "YulLiteral", + "src": "44999:1:0", + "type": "", + "value": "1" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "45006:1:0", + "nodeType": "YulIdentifier", + "src": "45006:1:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "L_BLIND_MPTR", + "nativeSrc": "45022:12:0", + "nodeType": "YulIdentifier", + "src": "45022:12:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "45016:5:0", + "nodeType": "YulIdentifier", + "src": "45016:5:0" + }, + "nativeSrc": "45016:19:0", + "nodeType": "YulFunctionCall", + "src": "45016:19:0" + }, + { + "arguments": [ + { + "name": "L_LAST_MPTR", + "nativeSrc": "45043:11:0", + "nodeType": "YulIdentifier", + "src": "45043:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "45037:5:0", + "nodeType": "YulIdentifier", + "src": "45037:5:0" + }, + "nativeSrc": "45037:18:0", + "nodeType": "YulFunctionCall", + "src": "45037:18:0" + }, + { + "name": "r", + "nativeSrc": "45057:1:0", + "nodeType": "YulIdentifier", + "src": "45057:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "45009:6:0", + "nodeType": "YulIdentifier", + "src": "45009:6:0" + }, + "nativeSrc": "45009:50:0", + "nodeType": "YulFunctionCall", + "src": "45009:50:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "45002:3:0", + "nodeType": "YulIdentifier", + "src": "45002:3:0" + }, + "nativeSrc": "45002:58:0", + "nodeType": "YulFunctionCall", + "src": "45002:58:0" + }, + { + "name": "r", + "nativeSrc": "45062:1:0", + "nodeType": "YulIdentifier", + "src": "45062:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "44992:6:0", + "nodeType": "YulIdentifier", + "src": "44992:6:0" + }, + "nativeSrc": "44992:72:0", + "nodeType": "YulFunctionCall", + "src": "44992:72:0" + }, + { + "arguments": [ + { + "name": "lhs", + "nativeSrc": "45073:3:0", + "nodeType": "YulIdentifier", + "src": "45073:3:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "45082:1:0", + "nodeType": "YulIdentifier", + "src": "45082:1:0" + }, + { + "name": "rhs", + "nativeSrc": "45085:3:0", + "nodeType": "YulIdentifier", + "src": "45085:3:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "45078:3:0", + "nodeType": "YulIdentifier", + "src": "45078:3:0" + }, + "nativeSrc": "45078:11:0", + "nodeType": "YulFunctionCall", + "src": "45078:11:0" + }, + { + "name": "r", + "nativeSrc": "45091:1:0", + "nodeType": "YulIdentifier", + "src": "45091:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "45066:6:0", + "nodeType": "YulIdentifier", + "src": "45066:6:0" + }, + "nativeSrc": "45066:27:0", + "nodeType": "YulFunctionCall", + "src": "45066:27:0" + }, + { + "name": "r", + "nativeSrc": "45095:1:0", + "nodeType": "YulIdentifier", + "src": "45095:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "44985:6:0", + "nodeType": "YulIdentifier", + "src": "44985:6:0" + }, + "nativeSrc": "44985:112:0", + "nodeType": "YulFunctionCall", + "src": "44985:112:0" + }, + "variables": [ + { + "name": "eval", + "nativeSrc": "44977:4:0", + "nodeType": "YulTypedName", + "src": "44977:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "45118:73:0", + "nodeType": "YulAssignment", + "src": "45118:73:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "45155:19:0", + "nodeType": "YulIdentifier", + "src": "45155:19:0" + }, + { + "name": "y", + "nativeSrc": "45176:1:0", + "nodeType": "YulIdentifier", + "src": "45176:1:0" + }, + { + "name": "r", + "nativeSrc": "45179:1:0", + "nodeType": "YulIdentifier", + "src": "45179:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "45148:6:0", + "nodeType": "YulIdentifier", + "src": "45148:6:0" + }, + "nativeSrc": "45148:33:0", + "nodeType": "YulFunctionCall", + "src": "45148:33:0" + }, + { + "name": "eval", + "nativeSrc": "45183:4:0", + "nodeType": "YulIdentifier", + "src": "45183:4:0" + }, + { + "name": "r", + "nativeSrc": "45189:1:0", + "nodeType": "YulIdentifier", + "src": "45189:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "45141:6:0", + "nodeType": "YulIdentifier", + "src": "45141:6:0" + }, + "nativeSrc": "45141:50:0", + "nodeType": "YulFunctionCall", + "src": "45141:50:0" + }, + "variableNames": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "45118:19:0", + "nodeType": "YulIdentifier", + "src": "45118:19:0" + } + ] + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "y", + "nativeSrc": "45231:1:0", + "nodeType": "YulIdentifier", + "src": "45231:1:0" + } + ], + "functionName": { + "name": "pop", + "nativeSrc": "45227:3:0", + "nodeType": "YulIdentifier", + "src": "45227:3:0" + }, + "nativeSrc": "45227:6:0", + "nodeType": "YulFunctionCall", + "src": "45227:6:0" + }, + "nativeSrc": "45227:6:0", + "nodeType": "YulExpressionStatement", + "src": "45227:6:0" + }, + { + "expression": { + "arguments": [ + { + "name": "delta", + "nativeSrc": "45254:5:0", + "nodeType": "YulIdentifier", + "src": "45254:5:0" + } + ], + "functionName": { + "name": "pop", + "nativeSrc": "45250:3:0", + "nodeType": "YulIdentifier", + "src": "45250:3:0" + }, + "nativeSrc": "45250:10:0", + "nodeType": "YulFunctionCall", + "src": "45250:10:0" + }, + "nativeSrc": "45250:10:0", + "nodeType": "YulExpressionStatement", + "src": "45250:10:0" + }, + { + "nativeSrc": "45278:80:0", + "nodeType": "YulVariableDeclaration", + "src": "45278:80:0", + "value": { + "arguments": [ + { + "name": "quotient_eval_numer", + "nativeSrc": "45306:19:0", + "nodeType": "YulIdentifier", + "src": "45306:19:0" + }, + { + "arguments": [ + { + "name": "X_N_MINUS_1_INV_MPTR", + "nativeSrc": "45333:20:0", + "nodeType": "YulIdentifier", + "src": "45333:20:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "45327:5:0", + "nodeType": "YulIdentifier", + "src": "45327:5:0" + }, + "nativeSrc": "45327:27:0", + "nodeType": "YulFunctionCall", + "src": "45327:27:0" + }, + { + "name": "r", + "nativeSrc": "45356:1:0", + "nodeType": "YulIdentifier", + "src": "45356:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "45299:6:0", + "nodeType": "YulIdentifier", + "src": "45299:6:0" + }, + "nativeSrc": "45299:59:0", + "nodeType": "YulFunctionCall", + "src": "45299:59:0" + }, + "variables": [ + { + "name": "quotient_eval", + "nativeSrc": "45282:13:0", + "nodeType": "YulTypedName", + "src": "45282:13:0", + "type": "" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "QUOTIENT_EVAL_MPTR", + "nativeSrc": "45382:18:0", + "nodeType": "YulIdentifier", + "src": "45382:18:0" + }, + { + "name": "quotient_eval", + "nativeSrc": "45402:13:0", + "nodeType": "YulIdentifier", + "src": "45402:13:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "45375:6:0", + "nodeType": "YulIdentifier", + "src": "45375:6:0" + }, + "nativeSrc": "45375:41:0", + "nodeType": "YulFunctionCall", + "src": "45375:41:0" + }, + "nativeSrc": "45375:41:0", + "nodeType": "YulExpressionStatement", + "src": "45375:41:0" + } + ] + }, + { + "nativeSrc": "45487:810:0", + "nodeType": "YulBlock", + "src": "45487:810:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "45512:4:0", + "nodeType": "YulLiteral", + "src": "45512:4:0", + "type": "", + "value": "0x00" + }, + { + "arguments": [ + { + "name": "LAST_QUOTIENT_X_CPTR", + "nativeSrc": "45531:20:0", + "nodeType": "YulIdentifier", + "src": "45531:20:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "45518:12:0", + "nodeType": "YulIdentifier", + "src": "45518:12:0" + }, + "nativeSrc": "45518:34:0", + "nodeType": "YulFunctionCall", + "src": "45518:34:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "45505:6:0", + "nodeType": "YulIdentifier", + "src": "45505:6:0" + }, + "nativeSrc": "45505:48:0", + "nodeType": "YulFunctionCall", + "src": "45505:48:0" + }, + "nativeSrc": "45505:48:0", + "nodeType": "YulExpressionStatement", + "src": "45505:48:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "45577:4:0", + "nodeType": "YulLiteral", + "src": "45577:4:0", + "type": "", + "value": "0x20" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "LAST_QUOTIENT_X_CPTR", + "nativeSrc": "45600:20:0", + "nodeType": "YulIdentifier", + "src": "45600:20:0" + }, + { + "kind": "number", + "nativeSrc": "45622:4:0", + "nodeType": "YulLiteral", + "src": "45622:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "45596:3:0", + "nodeType": "YulIdentifier", + "src": "45596:3:0" + }, + "nativeSrc": "45596:31:0", + "nodeType": "YulFunctionCall", + "src": "45596:31:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "45583:12:0", + "nodeType": "YulIdentifier", + "src": "45583:12:0" + }, + "nativeSrc": "45583:45:0", + "nodeType": "YulFunctionCall", + "src": "45583:45:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "45570:6:0", + "nodeType": "YulIdentifier", + "src": "45570:6:0" + }, + "nativeSrc": "45570:59:0", + "nodeType": "YulFunctionCall", + "src": "45570:59:0" + }, + "nativeSrc": "45570:59:0", + "nodeType": "YulExpressionStatement", + "src": "45570:59:0" + }, + { + "nativeSrc": "45646:26:0", + "nodeType": "YulVariableDeclaration", + "src": "45646:26:0", + "value": { + "arguments": [ + { + "name": "X_N_MPTR", + "nativeSrc": "45663:8:0", + "nodeType": "YulIdentifier", + "src": "45663:8:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "45657:5:0", + "nodeType": "YulIdentifier", + "src": "45657:5:0" + }, + "nativeSrc": "45657:15:0", + "nodeType": "YulFunctionCall", + "src": "45657:15:0" + }, + "variables": [ + { + "name": "x_n", + "nativeSrc": "45650:3:0", + "nodeType": "YulTypedName", + "src": "45650:3:0", + "type": "" + } + ] + }, + { + "body": { + "nativeSrc": "45956:221:0", + "nodeType": "YulBlock", + "src": "45956:221:0", + "statements": [ + { + "nativeSrc": "45978:35:0", + "nodeType": "YulAssignment", + "src": "45978:35:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "46000:7:0", + "nodeType": "YulIdentifier", + "src": "46000:7:0" + }, + { + "name": "x_n", + "nativeSrc": "46009:3:0", + "nodeType": "YulIdentifier", + "src": "46009:3:0" + } + ], + "functionName": { + "name": "ec_mul_acc", + "nativeSrc": "45989:10:0", + "nodeType": "YulIdentifier", + "src": "45989:10:0" + }, + "nativeSrc": "45989:24:0", + "nodeType": "YulFunctionCall", + "src": "45989:24:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "45978:7:0", + "nodeType": "YulIdentifier", + "src": "45978:7:0" + } + ] + }, + { + "nativeSrc": "46034:81:0", + "nodeType": "YulAssignment", + "src": "46034:81:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "46056:7:0", + "nodeType": "YulIdentifier", + "src": "46056:7:0" + }, + { + "arguments": [ + { + "name": "cptr", + "nativeSrc": "46078:4:0", + "nodeType": "YulIdentifier", + "src": "46078:4:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "46065:12:0", + "nodeType": "YulIdentifier", + "src": "46065:12:0" + }, + "nativeSrc": "46065:18:0", + "nodeType": "YulFunctionCall", + "src": "46065:18:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "cptr", + "nativeSrc": "46102:4:0", + "nodeType": "YulIdentifier", + "src": "46102:4:0" + }, + { + "kind": "number", + "nativeSrc": "46108:4:0", + "nodeType": "YulLiteral", + "src": "46108:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "46098:3:0", + "nodeType": "YulIdentifier", + "src": "46098:3:0" + }, + "nativeSrc": "46098:15:0", + "nodeType": "YulFunctionCall", + "src": "46098:15:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "46085:12:0", + "nodeType": "YulIdentifier", + "src": "46085:12:0" + }, + "nativeSrc": "46085:29:0", + "nodeType": "YulFunctionCall", + "src": "46085:29:0" + } + ], + "functionName": { + "name": "ec_add_acc", + "nativeSrc": "46045:10:0", + "nodeType": "YulIdentifier", + "src": "46045:10:0" + }, + "nativeSrc": "46045:70:0", + "nodeType": "YulFunctionCall", + "src": "46045:70:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "46034:7:0", + "nodeType": "YulIdentifier", + "src": "46034:7:0" + } + ] + }, + { + "nativeSrc": "46136:23:0", + "nodeType": "YulAssignment", + "src": "46136:23:0", + "value": { + "arguments": [ + { + "name": "cptr", + "nativeSrc": "46148:4:0", + "nodeType": "YulIdentifier", + "src": "46148:4:0" + }, + { + "kind": "number", + "nativeSrc": "46154:4:0", + "nodeType": "YulLiteral", + "src": "46154:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "46144:3:0", + "nodeType": "YulIdentifier", + "src": "46144:3:0" + }, + "nativeSrc": "46144:15:0", + "nodeType": "YulFunctionCall", + "src": "46144:15:0" + }, + "variableNames": [ + { + "name": "cptr", + "nativeSrc": "46136:4:0", + "nodeType": "YulIdentifier", + "src": "46136:4:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "cptr_end", + "nativeSrc": "45901:8:0", + "nodeType": "YulIdentifier", + "src": "45901:8:0" + }, + { + "name": "cptr", + "nativeSrc": "45911:4:0", + "nodeType": "YulIdentifier", + "src": "45911:4:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "45898:2:0", + "nodeType": "YulIdentifier", + "src": "45898:2:0" + }, + "nativeSrc": "45898:18:0", + "nodeType": "YulFunctionCall", + "src": "45898:18:0" + }, + "nativeSrc": "45689:488:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "45937:2:0", + "nodeType": "YulBlock", + "src": "45937:2:0", + "statements": [] + }, + "pre": { + "nativeSrc": "45713:164:0", + "nodeType": "YulBlock", + "src": "45713:164:0", + "statements": [ + { + "nativeSrc": "45739:43:0", + "nodeType": "YulVariableDeclaration", + "src": "45739:43:0", + "value": { + "arguments": [ + { + "name": "LAST_QUOTIENT_X_CPTR", + "nativeSrc": "45755:20:0", + "nodeType": "YulIdentifier", + "src": "45755:20:0" + }, + { + "kind": "number", + "nativeSrc": "45777:4:0", + "nodeType": "YulLiteral", + "src": "45777:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "45751:3:0", + "nodeType": "YulIdentifier", + "src": "45751:3:0" + }, + "nativeSrc": "45751:31:0", + "nodeType": "YulFunctionCall", + "src": "45751:31:0" + }, + "variables": [ + { + "name": "cptr", + "nativeSrc": "45743:4:0", + "nodeType": "YulTypedName", + "src": "45743:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "45807:48:0", + "nodeType": "YulVariableDeclaration", + "src": "45807:48:0", + "value": { + "arguments": [ + { + "name": "FIRST_QUOTIENT_X_CPTR", + "nativeSrc": "45827:21:0", + "nodeType": "YulIdentifier", + "src": "45827:21:0" + }, + { + "kind": "number", + "nativeSrc": "45850:4:0", + "nodeType": "YulLiteral", + "src": "45850:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "45823:3:0", + "nodeType": "YulIdentifier", + "src": "45823:3:0" + }, + "nativeSrc": "45823:32:0", + "nodeType": "YulFunctionCall", + "src": "45823:32:0" + }, + "variables": [ + { + "name": "cptr_end", + "nativeSrc": "45811:8:0", + "nodeType": "YulTypedName", + "src": "45811:8:0", + "type": "" + } + ] + } + ] + }, + "src": "45689:488:0" + }, + { + "expression": { + "arguments": [ + { + "name": "QUOTIENT_X_MPTR", + "nativeSrc": "46201:15:0", + "nodeType": "YulIdentifier", + "src": "46201:15:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "46224:4:0", + "nodeType": "YulLiteral", + "src": "46224:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "46218:5:0", + "nodeType": "YulIdentifier", + "src": "46218:5:0" + }, + "nativeSrc": "46218:11:0", + "nodeType": "YulFunctionCall", + "src": "46218:11:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "46194:6:0", + "nodeType": "YulIdentifier", + "src": "46194:6:0" + }, + "nativeSrc": "46194:36:0", + "nodeType": "YulFunctionCall", + "src": "46194:36:0" + }, + "nativeSrc": "46194:36:0", + "nodeType": "YulExpressionStatement", + "src": "46194:36:0" + }, + { + "expression": { + "arguments": [ + { + "name": "QUOTIENT_Y_MPTR", + "nativeSrc": "46254:15:0", + "nodeType": "YulIdentifier", + "src": "46254:15:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "46277:4:0", + "nodeType": "YulLiteral", + "src": "46277:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "46271:5:0", + "nodeType": "YulIdentifier", + "src": "46271:5:0" + }, + "nativeSrc": "46271:11:0", + "nodeType": "YulFunctionCall", + "src": "46271:11:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "46247:6:0", + "nodeType": "YulIdentifier", + "src": "46247:6:0" + }, + "nativeSrc": "46247:36:0", + "nodeType": "YulFunctionCall", + "src": "46247:36:0" + }, + "nativeSrc": "46247:36:0", + "nodeType": "YulExpressionStatement", + "src": "46247:36:0" + } + ] + }, + { + "nativeSrc": "46354:15359:0", + "nodeType": "YulBlock", + "src": "46354:15359:0", + "statements": [ + { + "nativeSrc": "46372:862:0", + "nodeType": "YulBlock", + "src": "46372:862:0", + "statements": [ + { + "nativeSrc": "46394:22:0", + "nodeType": "YulVariableDeclaration", + "src": "46394:22:0", + "value": { + "arguments": [ + { + "name": "X_MPTR", + "nativeSrc": "46409:6:0", + "nodeType": "YulIdentifier", + "src": "46409:6:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "46403:5:0", + "nodeType": "YulIdentifier", + "src": "46403:5:0" + }, + "nativeSrc": "46403:13:0", + "nodeType": "YulFunctionCall", + "src": "46403:13:0" + }, + "variables": [ + { + "name": "x", + "nativeSrc": "46398:1:0", + "nodeType": "YulTypedName", + "src": "46398:1:0", + "type": "" + } + ] + }, + { + "nativeSrc": "46437:30:0", + "nodeType": "YulVariableDeclaration", + "src": "46437:30:0", + "value": { + "arguments": [ + { + "name": "OMEGA_MPTR", + "nativeSrc": "46456:10:0", + "nodeType": "YulIdentifier", + "src": "46456:10:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "46450:5:0", + "nodeType": "YulIdentifier", + "src": "46450:5:0" + }, + "nativeSrc": "46450:17:0", + "nodeType": "YulFunctionCall", + "src": "46450:17:0" + }, + "variables": [ + { + "name": "omega", + "nativeSrc": "46441:5:0", + "nodeType": "YulTypedName", + "src": "46441:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "46488:38:0", + "nodeType": "YulVariableDeclaration", + "src": "46488:38:0", + "value": { + "arguments": [ + { + "name": "OMEGA_INV_MPTR", + "nativeSrc": "46511:14:0", + "nodeType": "YulIdentifier", + "src": "46511:14:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "46505:5:0", + "nodeType": "YulIdentifier", + "src": "46505:5:0" + }, + "nativeSrc": "46505:21:0", + "nodeType": "YulFunctionCall", + "src": "46505:21:0" + }, + "variables": [ + { + "name": "omega_inv", + "nativeSrc": "46492:9:0", + "nodeType": "YulTypedName", + "src": "46492:9:0", + "type": "" + } + ] + }, + { + "nativeSrc": "46547:41:0", + "nodeType": "YulVariableDeclaration", + "src": "46547:41:0", + "value": { + "arguments": [ + { + "name": "x", + "nativeSrc": "46576:1:0", + "nodeType": "YulIdentifier", + "src": "46576:1:0" + }, + { + "name": "omega", + "nativeSrc": "46579:5:0", + "nodeType": "YulIdentifier", + "src": "46579:5:0" + }, + { + "name": "r", + "nativeSrc": "46586:1:0", + "nodeType": "YulIdentifier", + "src": "46586:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "46569:6:0", + "nodeType": "YulIdentifier", + "src": "46569:6:0" + }, + "nativeSrc": "46569:19:0", + "nodeType": "YulFunctionCall", + "src": "46569:19:0" + }, + "variables": [ + { + "name": "x_pow_of_omega", + "nativeSrc": "46551:14:0", + "nodeType": "YulTypedName", + "src": "46551:14:0", + "type": "" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "46616:6:0", + "nodeType": "YulLiteral", + "src": "46616:6:0", + "type": "", + "value": "0x0360" + }, + { + "name": "x_pow_of_omega", + "nativeSrc": "46624:14:0", + "nodeType": "YulIdentifier", + "src": "46624:14:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "46609:6:0", + "nodeType": "YulIdentifier", + "src": "46609:6:0" + }, + "nativeSrc": "46609:30:0", + "nodeType": "YulFunctionCall", + "src": "46609:30:0" + }, + "nativeSrc": "46609:30:0", + "nodeType": "YulExpressionStatement", + "src": "46609:30:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "46667:6:0", + "nodeType": "YulLiteral", + "src": "46667:6:0", + "type": "", + "value": "0x0340" + }, + { + "name": "x", + "nativeSrc": "46675:1:0", + "nodeType": "YulIdentifier", + "src": "46675:1:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "46660:6:0", + "nodeType": "YulIdentifier", + "src": "46660:6:0" + }, + "nativeSrc": "46660:17:0", + "nodeType": "YulFunctionCall", + "src": "46660:17:0" + }, + "nativeSrc": "46660:17:0", + "nodeType": "YulExpressionStatement", + "src": "46660:17:0" + }, + { + "nativeSrc": "46698:41:0", + "nodeType": "YulAssignment", + "src": "46698:41:0", + "value": { + "arguments": [ + { + "name": "x", + "nativeSrc": "46723:1:0", + "nodeType": "YulIdentifier", + "src": "46723:1:0" + }, + { + "name": "omega_inv", + "nativeSrc": "46726:9:0", + "nodeType": "YulIdentifier", + "src": "46726:9:0" + }, + { + "name": "r", + "nativeSrc": "46737:1:0", + "nodeType": "YulIdentifier", + "src": "46737:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "46716:6:0", + "nodeType": "YulIdentifier", + "src": "46716:6:0" + }, + "nativeSrc": "46716:23:0", + "nodeType": "YulFunctionCall", + "src": "46716:23:0" + }, + "variableNames": [ + { + "name": "x_pow_of_omega", + "nativeSrc": "46698:14:0", + "nodeType": "YulIdentifier", + "src": "46698:14:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "46767:6:0", + "nodeType": "YulLiteral", + "src": "46767:6:0", + "type": "", + "value": "0x0320" + }, + { + "name": "x_pow_of_omega", + "nativeSrc": "46775:14:0", + "nodeType": "YulIdentifier", + "src": "46775:14:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "46760:6:0", + "nodeType": "YulIdentifier", + "src": "46760:6:0" + }, + "nativeSrc": "46760:30:0", + "nodeType": "YulFunctionCall", + "src": "46760:30:0" + }, + "nativeSrc": "46760:30:0", + "nodeType": "YulExpressionStatement", + "src": "46760:30:0" + }, + { + "nativeSrc": "46811:54:0", + "nodeType": "YulAssignment", + "src": "46811:54:0", + "value": { + "arguments": [ + { + "name": "x_pow_of_omega", + "nativeSrc": "46836:14:0", + "nodeType": "YulIdentifier", + "src": "46836:14:0" + }, + { + "name": "omega_inv", + "nativeSrc": "46852:9:0", + "nodeType": "YulIdentifier", + "src": "46852:9:0" + }, + { + "name": "r", + "nativeSrc": "46863:1:0", + "nodeType": "YulIdentifier", + "src": "46863:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "46829:6:0", + "nodeType": "YulIdentifier", + "src": "46829:6:0" + }, + "nativeSrc": "46829:36:0", + "nodeType": "YulFunctionCall", + "src": "46829:36:0" + }, + "variableNames": [ + { + "name": "x_pow_of_omega", + "nativeSrc": "46811:14:0", + "nodeType": "YulIdentifier", + "src": "46811:14:0" + } + ] + }, + { + "nativeSrc": "46886:54:0", + "nodeType": "YulAssignment", + "src": "46886:54:0", + "value": { + "arguments": [ + { + "name": "x_pow_of_omega", + "nativeSrc": "46911:14:0", + "nodeType": "YulIdentifier", + "src": "46911:14:0" + }, + { + "name": "omega_inv", + "nativeSrc": "46927:9:0", + "nodeType": "YulIdentifier", + "src": "46927:9:0" + }, + { + "name": "r", + "nativeSrc": "46938:1:0", + "nodeType": "YulIdentifier", + "src": "46938:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "46904:6:0", + "nodeType": "YulIdentifier", + "src": "46904:6:0" + }, + "nativeSrc": "46904:36:0", + "nodeType": "YulFunctionCall", + "src": "46904:36:0" + }, + "variableNames": [ + { + "name": "x_pow_of_omega", + "nativeSrc": "46886:14:0", + "nodeType": "YulIdentifier", + "src": "46886:14:0" + } + ] + }, + { + "nativeSrc": "46961:54:0", + "nodeType": "YulAssignment", + "src": "46961:54:0", + "value": { + "arguments": [ + { + "name": "x_pow_of_omega", + "nativeSrc": "46986:14:0", + "nodeType": "YulIdentifier", + "src": "46986:14:0" + }, + { + "name": "omega_inv", + "nativeSrc": "47002:9:0", + "nodeType": "YulIdentifier", + "src": "47002:9:0" + }, + { + "name": "r", + "nativeSrc": "47013:1:0", + "nodeType": "YulIdentifier", + "src": "47013:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "46979:6:0", + "nodeType": "YulIdentifier", + "src": "46979:6:0" + }, + "nativeSrc": "46979:36:0", + "nodeType": "YulFunctionCall", + "src": "46979:36:0" + }, + "variableNames": [ + { + "name": "x_pow_of_omega", + "nativeSrc": "46961:14:0", + "nodeType": "YulIdentifier", + "src": "46961:14:0" + } + ] + }, + { + "nativeSrc": "47036:54:0", + "nodeType": "YulAssignment", + "src": "47036:54:0", + "value": { + "arguments": [ + { + "name": "x_pow_of_omega", + "nativeSrc": "47061:14:0", + "nodeType": "YulIdentifier", + "src": "47061:14:0" + }, + { + "name": "omega_inv", + "nativeSrc": "47077:9:0", + "nodeType": "YulIdentifier", + "src": "47077:9:0" + }, + { + "name": "r", + "nativeSrc": "47088:1:0", + "nodeType": "YulIdentifier", + "src": "47088:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "47054:6:0", + "nodeType": "YulIdentifier", + "src": "47054:6:0" + }, + "nativeSrc": "47054:36:0", + "nodeType": "YulFunctionCall", + "src": "47054:36:0" + }, + "variableNames": [ + { + "name": "x_pow_of_omega", + "nativeSrc": "47036:14:0", + "nodeType": "YulIdentifier", + "src": "47036:14:0" + } + ] + }, + { + "nativeSrc": "47111:54:0", + "nodeType": "YulAssignment", + "src": "47111:54:0", + "value": { + "arguments": [ + { + "name": "x_pow_of_omega", + "nativeSrc": "47136:14:0", + "nodeType": "YulIdentifier", + "src": "47136:14:0" + }, + { + "name": "omega_inv", + "nativeSrc": "47152:9:0", + "nodeType": "YulIdentifier", + "src": "47152:9:0" + }, + { + "name": "r", + "nativeSrc": "47163:1:0", + "nodeType": "YulIdentifier", + "src": "47163:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "47129:6:0", + "nodeType": "YulIdentifier", + "src": "47129:6:0" + }, + "nativeSrc": "47129:36:0", + "nodeType": "YulFunctionCall", + "src": "47129:36:0" + }, + "variableNames": [ + { + "name": "x_pow_of_omega", + "nativeSrc": "47111:14:0", + "nodeType": "YulIdentifier", + "src": "47111:14:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "47193:6:0", + "nodeType": "YulLiteral", + "src": "47193:6:0", + "type": "", + "value": "0x0300" + }, + { + "name": "x_pow_of_omega", + "nativeSrc": "47201:14:0", + "nodeType": "YulIdentifier", + "src": "47201:14:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "47186:6:0", + "nodeType": "YulIdentifier", + "src": "47186:6:0" + }, + "nativeSrc": "47186:30:0", + "nodeType": "YulFunctionCall", + "src": "47186:30:0" + }, + "nativeSrc": "47186:30:0", + "nodeType": "YulExpressionStatement", + "src": "47186:30:0" + } + ] + }, + { + "nativeSrc": "47251:1364:0", + "nodeType": "YulBlock", + "src": "47251:1364:0", + "statements": [ + { + "nativeSrc": "47273:24:0", + "nodeType": "YulVariableDeclaration", + "src": "47273:24:0", + "value": { + "arguments": [ + { + "name": "MU_MPTR", + "nativeSrc": "47289:7:0", + "nodeType": "YulIdentifier", + "src": "47289:7:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "47283:5:0", + "nodeType": "YulIdentifier", + "src": "47283:5:0" + }, + "nativeSrc": "47283:14:0", + "nodeType": "YulFunctionCall", + "src": "47283:14:0" + }, + "variables": [ + { + "name": "mu", + "nativeSrc": "47277:2:0", + "nodeType": "YulTypedName", + "src": "47277:2:0", + "type": "" + } + ] + }, + { + "body": { + "nativeSrc": "47756:102:0", + "nodeType": "YulBlock", + "src": "47756:102:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "47789:4:0", + "nodeType": "YulIdentifier", + "src": "47789:4:0" + }, + { + "arguments": [ + { + "name": "mu", + "nativeSrc": "47802:2:0", + "nodeType": "YulIdentifier", + "src": "47802:2:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "47810:1:0", + "nodeType": "YulIdentifier", + "src": "47810:1:0" + }, + { + "arguments": [ + { + "name": "point_mptr", + "nativeSrc": "47819:10:0", + "nodeType": "YulIdentifier", + "src": "47819:10:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "47813:5:0", + "nodeType": "YulIdentifier", + "src": "47813:5:0" + }, + "nativeSrc": "47813:17:0", + "nodeType": "YulFunctionCall", + "src": "47813:17:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "47806:3:0", + "nodeType": "YulIdentifier", + "src": "47806:3:0" + }, + "nativeSrc": "47806:25:0", + "nodeType": "YulFunctionCall", + "src": "47806:25:0" + }, + { + "name": "r", + "nativeSrc": "47833:1:0", + "nodeType": "YulIdentifier", + "src": "47833:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "47795:6:0", + "nodeType": "YulIdentifier", + "src": "47795:6:0" + }, + "nativeSrc": "47795:40:0", + "nodeType": "YulFunctionCall", + "src": "47795:40:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "47782:6:0", + "nodeType": "YulIdentifier", + "src": "47782:6:0" + }, + "nativeSrc": "47782:54:0", + "nodeType": "YulFunctionCall", + "src": "47782:54:0" + }, + "nativeSrc": "47782:54:0", + "nodeType": "YulExpressionStatement", + "src": "47782:54:0" + } + ] + }, + "condition": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "47552:4:0", + "nodeType": "YulIdentifier", + "src": "47552:4:0" + }, + { + "name": "mptr_end", + "nativeSrc": "47558:8:0", + "nodeType": "YulIdentifier", + "src": "47558:8:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "47549:2:0", + "nodeType": "YulIdentifier", + "src": "47549:2:0" + }, + "nativeSrc": "47549:18:0", + "nodeType": "YulFunctionCall", + "src": "47549:18:0" + }, + "nativeSrc": "47318:540:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "47592:143:0", + "nodeType": "YulBlock", + "src": "47592:143:0", + "statements": [ + { + "nativeSrc": "47622:23:0", + "nodeType": "YulAssignment", + "src": "47622:23:0", + "value": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "47634:4:0", + "nodeType": "YulIdentifier", + "src": "47634:4:0" + }, + { + "kind": "number", + "nativeSrc": "47640:4:0", + "nodeType": "YulLiteral", + "src": "47640:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "47630:3:0", + "nodeType": "YulIdentifier", + "src": "47630:3:0" + }, + "nativeSrc": "47630:15:0", + "nodeType": "YulFunctionCall", + "src": "47630:15:0" + }, + "variableNames": [ + { + "name": "mptr", + "nativeSrc": "47622:4:0", + "nodeType": "YulIdentifier", + "src": "47622:4:0" + } + ] + }, + { + "nativeSrc": "47674:35:0", + "nodeType": "YulAssignment", + "src": "47674:35:0", + "value": { + "arguments": [ + { + "name": "point_mptr", + "nativeSrc": "47692:10:0", + "nodeType": "YulIdentifier", + "src": "47692:10:0" + }, + { + "kind": "number", + "nativeSrc": "47704:4:0", + "nodeType": "YulLiteral", + "src": "47704:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "47688:3:0", + "nodeType": "YulIdentifier", + "src": "47688:3:0" + }, + "nativeSrc": "47688:21:0", + "nodeType": "YulFunctionCall", + "src": "47688:21:0" + }, + "variableNames": [ + { + "name": "point_mptr", + "nativeSrc": "47674:10:0", + "nodeType": "YulIdentifier", + "src": "47674:10:0" + } + ] + } + ] + }, + "pre": { + "nativeSrc": "47346:178:0", + "nodeType": "YulBlock", + "src": "47346:178:0", + "statements": [ + { + "nativeSrc": "47376:18:0", + "nodeType": "YulVariableDeclaration", + "src": "47376:18:0", + "value": { + "kind": "number", + "nativeSrc": "47388:6:0", + "nodeType": "YulLiteral", + "src": "47388:6:0", + "type": "", + "value": "0x0380" + }, + "variables": [ + { + "name": "mptr", + "nativeSrc": "47380:4:0", + "nodeType": "YulTypedName", + "src": "47380:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "47423:22:0", + "nodeType": "YulVariableDeclaration", + "src": "47423:22:0", + "value": { + "kind": "number", + "nativeSrc": "47439:6:0", + "nodeType": "YulLiteral", + "src": "47439:6:0", + "type": "", + "value": "0x0400" + }, + "variables": [ + { + "name": "mptr_end", + "nativeSrc": "47427:8:0", + "nodeType": "YulTypedName", + "src": "47427:8:0", + "type": "" + } + ] + }, + { + "nativeSrc": "47474:24:0", + "nodeType": "YulVariableDeclaration", + "src": "47474:24:0", + "value": { + "kind": "number", + "nativeSrc": "47492:6:0", + "nodeType": "YulLiteral", + "src": "47492:6:0", + "type": "", + "value": "0x0300" + }, + "variables": [ + { + "name": "point_mptr", + "nativeSrc": "47478:10:0", + "nodeType": "YulTypedName", + "src": "47478:10:0", + "type": "" + } + ] + } + ] + }, + "src": "47318:540:0" + }, + { + "nativeSrc": "47879:5:0", + "nodeType": "YulVariableDeclaration", + "src": "47879:5:0", + "variables": [ + { + "name": "s", + "nativeSrc": "47883:1:0", + "nodeType": "YulTypedName", + "src": "47883:1:0", + "type": "" + } + ] + }, + { + "nativeSrc": "47905:18:0", + "nodeType": "YulAssignment", + "src": "47905:18:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "47916:6:0", + "nodeType": "YulLiteral", + "src": "47916:6:0", + "type": "", + "value": "0x03c0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "47910:5:0", + "nodeType": "YulIdentifier", + "src": "47910:5:0" + }, + "nativeSrc": "47910:13:0", + "nodeType": "YulFunctionCall", + "src": "47910:13:0" + }, + "variableNames": [ + { + "name": "s", + "nativeSrc": "47905:1:0", + "nodeType": "YulIdentifier", + "src": "47905:1:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "47951:6:0", + "nodeType": "YulLiteral", + "src": "47951:6:0", + "type": "", + "value": "0x0400" + }, + { + "name": "s", + "nativeSrc": "47959:1:0", + "nodeType": "YulIdentifier", + "src": "47959:1:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "47944:6:0", + "nodeType": "YulIdentifier", + "src": "47944:6:0" + }, + "nativeSrc": "47944:17:0", + "nodeType": "YulFunctionCall", + "src": "47944:17:0" + }, + "nativeSrc": "47944:17:0", + "nodeType": "YulExpressionStatement", + "src": "47944:17:0" + }, + { + "nativeSrc": "47982:8:0", + "nodeType": "YulVariableDeclaration", + "src": "47982:8:0", + "variables": [ + { + "name": "diff", + "nativeSrc": "47986:4:0", + "nodeType": "YulTypedName", + "src": "47986:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "48011:21:0", + "nodeType": "YulAssignment", + "src": "48011:21:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48025:6:0", + "nodeType": "YulLiteral", + "src": "48025:6:0", + "type": "", + "value": "0x0380" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "48019:5:0", + "nodeType": "YulIdentifier", + "src": "48019:5:0" + }, + "nativeSrc": "48019:13:0", + "nodeType": "YulFunctionCall", + "src": "48019:13:0" + }, + "variableNames": [ + { + "name": "diff", + "nativeSrc": "48011:4:0", + "nodeType": "YulIdentifier", + "src": "48011:4:0" + } + ] + }, + { + "nativeSrc": "48053:38:0", + "nodeType": "YulAssignment", + "src": "48053:38:0", + "value": { + "arguments": [ + { + "name": "diff", + "nativeSrc": "48068:4:0", + "nodeType": "YulIdentifier", + "src": "48068:4:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48080:6:0", + "nodeType": "YulLiteral", + "src": "48080:6:0", + "type": "", + "value": "0x03a0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "48074:5:0", + "nodeType": "YulIdentifier", + "src": "48074:5:0" + }, + "nativeSrc": "48074:13:0", + "nodeType": "YulFunctionCall", + "src": "48074:13:0" + }, + { + "name": "r", + "nativeSrc": "48089:1:0", + "nodeType": "YulIdentifier", + "src": "48089:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "48061:6:0", + "nodeType": "YulIdentifier", + "src": "48061:6:0" + }, + "nativeSrc": "48061:30:0", + "nodeType": "YulFunctionCall", + "src": "48061:30:0" + }, + "variableNames": [ + { + "name": "diff", + "nativeSrc": "48053:4:0", + "nodeType": "YulIdentifier", + "src": "48053:4:0" + } + ] + }, + { + "nativeSrc": "48112:38:0", + "nodeType": "YulAssignment", + "src": "48112:38:0", + "value": { + "arguments": [ + { + "name": "diff", + "nativeSrc": "48127:4:0", + "nodeType": "YulIdentifier", + "src": "48127:4:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48139:6:0", + "nodeType": "YulLiteral", + "src": "48139:6:0", + "type": "", + "value": "0x03e0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "48133:5:0", + "nodeType": "YulIdentifier", + "src": "48133:5:0" + }, + "nativeSrc": "48133:13:0", + "nodeType": "YulFunctionCall", + "src": "48133:13:0" + }, + { + "name": "r", + "nativeSrc": "48148:1:0", + "nodeType": "YulIdentifier", + "src": "48148:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "48120:6:0", + "nodeType": "YulIdentifier", + "src": "48120:6:0" + }, + "nativeSrc": "48120:30:0", + "nodeType": "YulFunctionCall", + "src": "48120:30:0" + }, + "variableNames": [ + { + "name": "diff", + "nativeSrc": "48112:4:0", + "nodeType": "YulIdentifier", + "src": "48112:4:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48178:6:0", + "nodeType": "YulLiteral", + "src": "48178:6:0", + "type": "", + "value": "0x0420" + }, + { + "name": "diff", + "nativeSrc": "48186:4:0", + "nodeType": "YulIdentifier", + "src": "48186:4:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "48171:6:0", + "nodeType": "YulIdentifier", + "src": "48171:6:0" + }, + "nativeSrc": "48171:20:0", + "nodeType": "YulFunctionCall", + "src": "48171:20:0" + }, + "nativeSrc": "48171:20:0", + "nodeType": "YulExpressionStatement", + "src": "48171:20:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48219:4:0", + "nodeType": "YulLiteral", + "src": "48219:4:0", + "type": "", + "value": "0x00" + }, + { + "name": "diff", + "nativeSrc": "48225:4:0", + "nodeType": "YulIdentifier", + "src": "48225:4:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "48212:6:0", + "nodeType": "YulIdentifier", + "src": "48212:6:0" + }, + "nativeSrc": "48212:18:0", + "nodeType": "YulFunctionCall", + "src": "48212:18:0" + }, + "nativeSrc": "48212:18:0", + "nodeType": "YulExpressionStatement", + "src": "48212:18:0" + }, + { + "nativeSrc": "48251:21:0", + "nodeType": "YulAssignment", + "src": "48251:21:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48265:6:0", + "nodeType": "YulLiteral", + "src": "48265:6:0", + "type": "", + "value": "0x0380" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "48259:5:0", + "nodeType": "YulIdentifier", + "src": "48259:5:0" + }, + "nativeSrc": "48259:13:0", + "nodeType": "YulFunctionCall", + "src": "48259:13:0" + }, + "variableNames": [ + { + "name": "diff", + "nativeSrc": "48251:4:0", + "nodeType": "YulIdentifier", + "src": "48251:4:0" + } + ] + }, + { + "nativeSrc": "48293:38:0", + "nodeType": "YulAssignment", + "src": "48293:38:0", + "value": { + "arguments": [ + { + "name": "diff", + "nativeSrc": "48308:4:0", + "nodeType": "YulIdentifier", + "src": "48308:4:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48320:6:0", + "nodeType": "YulLiteral", + "src": "48320:6:0", + "type": "", + "value": "0x03e0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "48314:5:0", + "nodeType": "YulIdentifier", + "src": "48314:5:0" + }, + "nativeSrc": "48314:13:0", + "nodeType": "YulFunctionCall", + "src": "48314:13:0" + }, + { + "name": "r", + "nativeSrc": "48329:1:0", + "nodeType": "YulIdentifier", + "src": "48329:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "48301:6:0", + "nodeType": "YulIdentifier", + "src": "48301:6:0" + }, + "nativeSrc": "48301:30:0", + "nodeType": "YulFunctionCall", + "src": "48301:30:0" + }, + "variableNames": [ + { + "name": "diff", + "nativeSrc": "48293:4:0", + "nodeType": "YulIdentifier", + "src": "48293:4:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48359:6:0", + "nodeType": "YulLiteral", + "src": "48359:6:0", + "type": "", + "value": "0x0440" + }, + { + "name": "diff", + "nativeSrc": "48367:4:0", + "nodeType": "YulIdentifier", + "src": "48367:4:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "48352:6:0", + "nodeType": "YulIdentifier", + "src": "48352:6:0" + }, + "nativeSrc": "48352:20:0", + "nodeType": "YulFunctionCall", + "src": "48352:20:0" + }, + "nativeSrc": "48352:20:0", + "nodeType": "YulExpressionStatement", + "src": "48352:20:0" + }, + { + "nativeSrc": "48393:21:0", + "nodeType": "YulAssignment", + "src": "48393:21:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48407:6:0", + "nodeType": "YulLiteral", + "src": "48407:6:0", + "type": "", + "value": "0x03a0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "48401:5:0", + "nodeType": "YulIdentifier", + "src": "48401:5:0" + }, + "nativeSrc": "48401:13:0", + "nodeType": "YulFunctionCall", + "src": "48401:13:0" + }, + "variableNames": [ + { + "name": "diff", + "nativeSrc": "48393:4:0", + "nodeType": "YulIdentifier", + "src": "48393:4:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48442:6:0", + "nodeType": "YulLiteral", + "src": "48442:6:0", + "type": "", + "value": "0x0460" + }, + { + "name": "diff", + "nativeSrc": "48450:4:0", + "nodeType": "YulIdentifier", + "src": "48450:4:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "48435:6:0", + "nodeType": "YulIdentifier", + "src": "48435:6:0" + }, + "nativeSrc": "48435:20:0", + "nodeType": "YulFunctionCall", + "src": "48435:20:0" + }, + "nativeSrc": "48435:20:0", + "nodeType": "YulExpressionStatement", + "src": "48435:20:0" + }, + { + "nativeSrc": "48476:21:0", + "nodeType": "YulAssignment", + "src": "48476:21:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48490:6:0", + "nodeType": "YulLiteral", + "src": "48490:6:0", + "type": "", + "value": "0x0380" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "48484:5:0", + "nodeType": "YulIdentifier", + "src": "48484:5:0" + }, + "nativeSrc": "48484:13:0", + "nodeType": "YulFunctionCall", + "src": "48484:13:0" + }, + "variableNames": [ + { + "name": "diff", + "nativeSrc": "48476:4:0", + "nodeType": "YulIdentifier", + "src": "48476:4:0" + } + ] + }, + { + "nativeSrc": "48518:38:0", + "nodeType": "YulAssignment", + "src": "48518:38:0", + "value": { + "arguments": [ + { + "name": "diff", + "nativeSrc": "48533:4:0", + "nodeType": "YulIdentifier", + "src": "48533:4:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48545:6:0", + "nodeType": "YulLiteral", + "src": "48545:6:0", + "type": "", + "value": "0x03a0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "48539:5:0", + "nodeType": "YulIdentifier", + "src": "48539:5:0" + }, + "nativeSrc": "48539:13:0", + "nodeType": "YulFunctionCall", + "src": "48539:13:0" + }, + { + "name": "r", + "nativeSrc": "48554:1:0", + "nodeType": "YulIdentifier", + "src": "48554:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "48526:6:0", + "nodeType": "YulIdentifier", + "src": "48526:6:0" + }, + "nativeSrc": "48526:30:0", + "nodeType": "YulFunctionCall", + "src": "48526:30:0" + }, + "variableNames": [ + { + "name": "diff", + "nativeSrc": "48518:4:0", + "nodeType": "YulIdentifier", + "src": "48518:4:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48584:6:0", + "nodeType": "YulLiteral", + "src": "48584:6:0", + "type": "", + "value": "0x0480" + }, + { + "name": "diff", + "nativeSrc": "48592:4:0", + "nodeType": "YulIdentifier", + "src": "48592:4:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "48577:6:0", + "nodeType": "YulIdentifier", + "src": "48577:6:0" + }, + "nativeSrc": "48577:20:0", + "nodeType": "YulFunctionCall", + "src": "48577:20:0" + }, + "nativeSrc": "48577:20:0", + "nodeType": "YulExpressionStatement", + "src": "48577:20:0" + } + ] + }, + { + "nativeSrc": "48632:230:0", + "nodeType": "YulBlock", + "src": "48632:230:0", + "statements": [ + { + "nativeSrc": "48654:28:0", + "nodeType": "YulVariableDeclaration", + "src": "48654:28:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48675:6:0", + "nodeType": "YulLiteral", + "src": "48675:6:0", + "type": "", + "value": "0x0340" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "48669:5:0", + "nodeType": "YulIdentifier", + "src": "48669:5:0" + }, + "nativeSrc": "48669:13:0", + "nodeType": "YulFunctionCall", + "src": "48669:13:0" + }, + "variables": [ + { + "name": "point_2", + "nativeSrc": "48658:7:0", + "nodeType": "YulTypedName", + "src": "48658:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "48703:9:0", + "nodeType": "YulVariableDeclaration", + "src": "48703:9:0", + "variables": [ + { + "name": "coeff", + "nativeSrc": "48707:5:0", + "nodeType": "YulTypedName", + "src": "48707:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "48733:10:0", + "nodeType": "YulAssignment", + "src": "48733:10:0", + "value": { + "kind": "number", + "nativeSrc": "48742:1:0", + "nodeType": "YulLiteral", + "src": "48742:1:0", + "type": "", + "value": "1" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "48733:5:0", + "nodeType": "YulIdentifier", + "src": "48733:5:0" + } + ] + }, + { + "nativeSrc": "48764:40:0", + "nodeType": "YulAssignment", + "src": "48764:40:0", + "value": { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "48780:5:0", + "nodeType": "YulIdentifier", + "src": "48780:5:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48793:6:0", + "nodeType": "YulLiteral", + "src": "48793:6:0", + "type": "", + "value": "0x03c0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "48787:5:0", + "nodeType": "YulIdentifier", + "src": "48787:5:0" + }, + "nativeSrc": "48787:13:0", + "nodeType": "YulFunctionCall", + "src": "48787:13:0" + }, + { + "name": "r", + "nativeSrc": "48802:1:0", + "nodeType": "YulIdentifier", + "src": "48802:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "48773:6:0", + "nodeType": "YulIdentifier", + "src": "48773:6:0" + }, + "nativeSrc": "48773:31:0", + "nodeType": "YulFunctionCall", + "src": "48773:31:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "48764:5:0", + "nodeType": "YulIdentifier", + "src": "48764:5:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48832:4:0", + "nodeType": "YulLiteral", + "src": "48832:4:0", + "type": "", + "value": "0x20" + }, + { + "name": "coeff", + "nativeSrc": "48838:5:0", + "nodeType": "YulIdentifier", + "src": "48838:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "48825:6:0", + "nodeType": "YulIdentifier", + "src": "48825:6:0" + }, + "nativeSrc": "48825:19:0", + "nodeType": "YulFunctionCall", + "src": "48825:19:0" + }, + "nativeSrc": "48825:19:0", + "nodeType": "YulExpressionStatement", + "src": "48825:19:0" + } + ] + }, + { + "nativeSrc": "48879:479:0", + "nodeType": "YulBlock", + "src": "48879:479:0", + "statements": [ + { + "nativeSrc": "48901:28:0", + "nodeType": "YulVariableDeclaration", + "src": "48901:28:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48922:6:0", + "nodeType": "YulLiteral", + "src": "48922:6:0", + "type": "", + "value": "0x0320" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "48916:5:0", + "nodeType": "YulIdentifier", + "src": "48916:5:0" + }, + "nativeSrc": "48916:13:0", + "nodeType": "YulFunctionCall", + "src": "48916:13:0" + }, + "variables": [ + { + "name": "point_1", + "nativeSrc": "48905:7:0", + "nodeType": "YulTypedName", + "src": "48905:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "48950:28:0", + "nodeType": "YulVariableDeclaration", + "src": "48950:28:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "48971:6:0", + "nodeType": "YulLiteral", + "src": "48971:6:0", + "type": "", + "value": "0x0340" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "48965:5:0", + "nodeType": "YulIdentifier", + "src": "48965:5:0" + }, + "nativeSrc": "48965:13:0", + "nodeType": "YulFunctionCall", + "src": "48965:13:0" + }, + "variables": [ + { + "name": "point_2", + "nativeSrc": "48954:7:0", + "nodeType": "YulTypedName", + "src": "48954:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "48999:9:0", + "nodeType": "YulVariableDeclaration", + "src": "48999:9:0", + "variables": [ + { + "name": "coeff", + "nativeSrc": "49003:5:0", + "nodeType": "YulTypedName", + "src": "49003:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "49029:44:0", + "nodeType": "YulAssignment", + "src": "49029:44:0", + "value": { + "arguments": [ + { + "name": "point_1", + "nativeSrc": "49045:7:0", + "nodeType": "YulIdentifier", + "src": "49045:7:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "49058:1:0", + "nodeType": "YulIdentifier", + "src": "49058:1:0" + }, + { + "name": "point_2", + "nativeSrc": "49061:7:0", + "nodeType": "YulIdentifier", + "src": "49061:7:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "49054:3:0", + "nodeType": "YulIdentifier", + "src": "49054:3:0" + }, + "nativeSrc": "49054:15:0", + "nodeType": "YulFunctionCall", + "src": "49054:15:0" + }, + { + "name": "r", + "nativeSrc": "49071:1:0", + "nodeType": "YulIdentifier", + "src": "49071:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "49038:6:0", + "nodeType": "YulIdentifier", + "src": "49038:6:0" + }, + "nativeSrc": "49038:35:0", + "nodeType": "YulFunctionCall", + "src": "49038:35:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "49029:5:0", + "nodeType": "YulIdentifier", + "src": "49029:5:0" + } + ] + }, + { + "nativeSrc": "49094:40:0", + "nodeType": "YulAssignment", + "src": "49094:40:0", + "value": { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "49110:5:0", + "nodeType": "YulIdentifier", + "src": "49110:5:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "49123:6:0", + "nodeType": "YulLiteral", + "src": "49123:6:0", + "type": "", + "value": "0x03a0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "49117:5:0", + "nodeType": "YulIdentifier", + "src": "49117:5:0" + }, + "nativeSrc": "49117:13:0", + "nodeType": "YulFunctionCall", + "src": "49117:13:0" + }, + { + "name": "r", + "nativeSrc": "49132:1:0", + "nodeType": "YulIdentifier", + "src": "49132:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "49103:6:0", + "nodeType": "YulIdentifier", + "src": "49103:6:0" + }, + "nativeSrc": "49103:31:0", + "nodeType": "YulFunctionCall", + "src": "49103:31:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "49094:5:0", + "nodeType": "YulIdentifier", + "src": "49094:5:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "49162:4:0", + "nodeType": "YulLiteral", + "src": "49162:4:0", + "type": "", + "value": "0x40" + }, + { + "name": "coeff", + "nativeSrc": "49168:5:0", + "nodeType": "YulIdentifier", + "src": "49168:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "49155:6:0", + "nodeType": "YulIdentifier", + "src": "49155:6:0" + }, + "nativeSrc": "49155:19:0", + "nodeType": "YulFunctionCall", + "src": "49155:19:0" + }, + "nativeSrc": "49155:19:0", + "nodeType": "YulExpressionStatement", + "src": "49155:19:0" + }, + { + "nativeSrc": "49195:44:0", + "nodeType": "YulAssignment", + "src": "49195:44:0", + "value": { + "arguments": [ + { + "name": "point_2", + "nativeSrc": "49211:7:0", + "nodeType": "YulIdentifier", + "src": "49211:7:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "49224:1:0", + "nodeType": "YulIdentifier", + "src": "49224:1:0" + }, + { + "name": "point_1", + "nativeSrc": "49227:7:0", + "nodeType": "YulIdentifier", + "src": "49227:7:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "49220:3:0", + "nodeType": "YulIdentifier", + "src": "49220:3:0" + }, + "nativeSrc": "49220:15:0", + "nodeType": "YulFunctionCall", + "src": "49220:15:0" + }, + { + "name": "r", + "nativeSrc": "49237:1:0", + "nodeType": "YulIdentifier", + "src": "49237:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "49204:6:0", + "nodeType": "YulIdentifier", + "src": "49204:6:0" + }, + "nativeSrc": "49204:35:0", + "nodeType": "YulFunctionCall", + "src": "49204:35:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "49195:5:0", + "nodeType": "YulIdentifier", + "src": "49195:5:0" + } + ] + }, + { + "nativeSrc": "49260:40:0", + "nodeType": "YulAssignment", + "src": "49260:40:0", + "value": { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "49276:5:0", + "nodeType": "YulIdentifier", + "src": "49276:5:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "49289:6:0", + "nodeType": "YulLiteral", + "src": "49289:6:0", + "type": "", + "value": "0x03c0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "49283:5:0", + "nodeType": "YulIdentifier", + "src": "49283:5:0" + }, + "nativeSrc": "49283:13:0", + "nodeType": "YulFunctionCall", + "src": "49283:13:0" + }, + { + "name": "r", + "nativeSrc": "49298:1:0", + "nodeType": "YulIdentifier", + "src": "49298:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "49269:6:0", + "nodeType": "YulIdentifier", + "src": "49269:6:0" + }, + "nativeSrc": "49269:31:0", + "nodeType": "YulFunctionCall", + "src": "49269:31:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "49260:5:0", + "nodeType": "YulIdentifier", + "src": "49260:5:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "49328:4:0", + "nodeType": "YulLiteral", + "src": "49328:4:0", + "type": "", + "value": "0x60" + }, + { + "name": "coeff", + "nativeSrc": "49334:5:0", + "nodeType": "YulIdentifier", + "src": "49334:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "49321:6:0", + "nodeType": "YulIdentifier", + "src": "49321:6:0" + }, + "nativeSrc": "49321:19:0", + "nodeType": "YulFunctionCall", + "src": "49321:19:0" + }, + "nativeSrc": "49321:19:0", + "nodeType": "YulExpressionStatement", + "src": "49321:19:0" + } + ] + }, + { + "nativeSrc": "49375:943:0", + "nodeType": "YulBlock", + "src": "49375:943:0", + "statements": [ + { + "nativeSrc": "49397:28:0", + "nodeType": "YulVariableDeclaration", + "src": "49397:28:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "49418:6:0", + "nodeType": "YulLiteral", + "src": "49418:6:0", + "type": "", + "value": "0x0300" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "49412:5:0", + "nodeType": "YulIdentifier", + "src": "49412:5:0" + }, + "nativeSrc": "49412:13:0", + "nodeType": "YulFunctionCall", + "src": "49412:13:0" + }, + "variables": [ + { + "name": "point_0", + "nativeSrc": "49401:7:0", + "nodeType": "YulTypedName", + "src": "49401:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "49446:28:0", + "nodeType": "YulVariableDeclaration", + "src": "49446:28:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "49467:6:0", + "nodeType": "YulLiteral", + "src": "49467:6:0", + "type": "", + "value": "0x0340" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "49461:5:0", + "nodeType": "YulIdentifier", + "src": "49461:5:0" + }, + "nativeSrc": "49461:13:0", + "nodeType": "YulFunctionCall", + "src": "49461:13:0" + }, + "variables": [ + { + "name": "point_2", + "nativeSrc": "49450:7:0", + "nodeType": "YulTypedName", + "src": "49450:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "49495:28:0", + "nodeType": "YulVariableDeclaration", + "src": "49495:28:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "49516:6:0", + "nodeType": "YulLiteral", + "src": "49516:6:0", + "type": "", + "value": "0x0360" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "49510:5:0", + "nodeType": "YulIdentifier", + "src": "49510:5:0" + }, + "nativeSrc": "49510:13:0", + "nodeType": "YulFunctionCall", + "src": "49510:13:0" + }, + "variables": [ + { + "name": "point_3", + "nativeSrc": "49499:7:0", + "nodeType": "YulTypedName", + "src": "49499:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "49544:9:0", + "nodeType": "YulVariableDeclaration", + "src": "49544:9:0", + "variables": [ + { + "name": "coeff", + "nativeSrc": "49548:5:0", + "nodeType": "YulTypedName", + "src": "49548:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "49574:44:0", + "nodeType": "YulAssignment", + "src": "49574:44:0", + "value": { + "arguments": [ + { + "name": "point_0", + "nativeSrc": "49590:7:0", + "nodeType": "YulIdentifier", + "src": "49590:7:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "49603:1:0", + "nodeType": "YulIdentifier", + "src": "49603:1:0" + }, + { + "name": "point_2", + "nativeSrc": "49606:7:0", + "nodeType": "YulIdentifier", + "src": "49606:7:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "49599:3:0", + "nodeType": "YulIdentifier", + "src": "49599:3:0" + }, + "nativeSrc": "49599:15:0", + "nodeType": "YulFunctionCall", + "src": "49599:15:0" + }, + { + "name": "r", + "nativeSrc": "49616:1:0", + "nodeType": "YulIdentifier", + "src": "49616:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "49583:6:0", + "nodeType": "YulIdentifier", + "src": "49583:6:0" + }, + "nativeSrc": "49583:35:0", + "nodeType": "YulFunctionCall", + "src": "49583:35:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "49574:5:0", + "nodeType": "YulIdentifier", + "src": "49574:5:0" + } + ] + }, + { + "nativeSrc": "49639:62:0", + "nodeType": "YulAssignment", + "src": "49639:62:0", + "value": { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "49655:5:0", + "nodeType": "YulIdentifier", + "src": "49655:5:0" + }, + { + "arguments": [ + { + "name": "point_0", + "nativeSrc": "49669:7:0", + "nodeType": "YulIdentifier", + "src": "49669:7:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "49682:1:0", + "nodeType": "YulIdentifier", + "src": "49682:1:0" + }, + { + "name": "point_3", + "nativeSrc": "49685:7:0", + "nodeType": "YulIdentifier", + "src": "49685:7:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "49678:3:0", + "nodeType": "YulIdentifier", + "src": "49678:3:0" + }, + "nativeSrc": "49678:15:0", + "nodeType": "YulFunctionCall", + "src": "49678:15:0" + }, + { + "name": "r", + "nativeSrc": "49695:1:0", + "nodeType": "YulIdentifier", + "src": "49695:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "49662:6:0", + "nodeType": "YulIdentifier", + "src": "49662:6:0" + }, + "nativeSrc": "49662:35:0", + "nodeType": "YulFunctionCall", + "src": "49662:35:0" + }, + { + "name": "r", + "nativeSrc": "49699:1:0", + "nodeType": "YulIdentifier", + "src": "49699:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "49648:6:0", + "nodeType": "YulIdentifier", + "src": "49648:6:0" + }, + "nativeSrc": "49648:53:0", + "nodeType": "YulFunctionCall", + "src": "49648:53:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "49639:5:0", + "nodeType": "YulIdentifier", + "src": "49639:5:0" + } + ] + }, + { + "nativeSrc": "49722:40:0", + "nodeType": "YulAssignment", + "src": "49722:40:0", + "value": { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "49738:5:0", + "nodeType": "YulIdentifier", + "src": "49738:5:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "49751:6:0", + "nodeType": "YulLiteral", + "src": "49751:6:0", + "type": "", + "value": "0x0380" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "49745:5:0", + "nodeType": "YulIdentifier", + "src": "49745:5:0" + }, + "nativeSrc": "49745:13:0", + "nodeType": "YulFunctionCall", + "src": "49745:13:0" + }, + { + "name": "r", + "nativeSrc": "49760:1:0", + "nodeType": "YulIdentifier", + "src": "49760:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "49731:6:0", + "nodeType": "YulIdentifier", + "src": "49731:6:0" + }, + "nativeSrc": "49731:31:0", + "nodeType": "YulFunctionCall", + "src": "49731:31:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "49722:5:0", + "nodeType": "YulIdentifier", + "src": "49722:5:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "49790:4:0", + "nodeType": "YulLiteral", + "src": "49790:4:0", + "type": "", + "value": "0x80" + }, + { + "name": "coeff", + "nativeSrc": "49796:5:0", + "nodeType": "YulIdentifier", + "src": "49796:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "49783:6:0", + "nodeType": "YulIdentifier", + "src": "49783:6:0" + }, + "nativeSrc": "49783:19:0", + "nodeType": "YulFunctionCall", + "src": "49783:19:0" + }, + "nativeSrc": "49783:19:0", + "nodeType": "YulExpressionStatement", + "src": "49783:19:0" + }, + { + "nativeSrc": "49823:44:0", + "nodeType": "YulAssignment", + "src": "49823:44:0", + "value": { + "arguments": [ + { + "name": "point_2", + "nativeSrc": "49839:7:0", + "nodeType": "YulIdentifier", + "src": "49839:7:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "49852:1:0", + "nodeType": "YulIdentifier", + "src": "49852:1:0" + }, + { + "name": "point_0", + "nativeSrc": "49855:7:0", + "nodeType": "YulIdentifier", + "src": "49855:7:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "49848:3:0", + "nodeType": "YulIdentifier", + "src": "49848:3:0" + }, + "nativeSrc": "49848:15:0", + "nodeType": "YulFunctionCall", + "src": "49848:15:0" + }, + { + "name": "r", + "nativeSrc": "49865:1:0", + "nodeType": "YulIdentifier", + "src": "49865:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "49832:6:0", + "nodeType": "YulIdentifier", + "src": "49832:6:0" + }, + "nativeSrc": "49832:35:0", + "nodeType": "YulFunctionCall", + "src": "49832:35:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "49823:5:0", + "nodeType": "YulIdentifier", + "src": "49823:5:0" + } + ] + }, + { + "nativeSrc": "49888:62:0", + "nodeType": "YulAssignment", + "src": "49888:62:0", + "value": { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "49904:5:0", + "nodeType": "YulIdentifier", + "src": "49904:5:0" + }, + { + "arguments": [ + { + "name": "point_2", + "nativeSrc": "49918:7:0", + "nodeType": "YulIdentifier", + "src": "49918:7:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "49931:1:0", + "nodeType": "YulIdentifier", + "src": "49931:1:0" + }, + { + "name": "point_3", + "nativeSrc": "49934:7:0", + "nodeType": "YulIdentifier", + "src": "49934:7:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "49927:3:0", + "nodeType": "YulIdentifier", + "src": "49927:3:0" + }, + "nativeSrc": "49927:15:0", + "nodeType": "YulFunctionCall", + "src": "49927:15:0" + }, + { + "name": "r", + "nativeSrc": "49944:1:0", + "nodeType": "YulIdentifier", + "src": "49944:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "49911:6:0", + "nodeType": "YulIdentifier", + "src": "49911:6:0" + }, + "nativeSrc": "49911:35:0", + "nodeType": "YulFunctionCall", + "src": "49911:35:0" + }, + { + "name": "r", + "nativeSrc": "49948:1:0", + "nodeType": "YulIdentifier", + "src": "49948:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "49897:6:0", + "nodeType": "YulIdentifier", + "src": "49897:6:0" + }, + "nativeSrc": "49897:53:0", + "nodeType": "YulFunctionCall", + "src": "49897:53:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "49888:5:0", + "nodeType": "YulIdentifier", + "src": "49888:5:0" + } + ] + }, + { + "nativeSrc": "49971:40:0", + "nodeType": "YulAssignment", + "src": "49971:40:0", + "value": { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "49987:5:0", + "nodeType": "YulIdentifier", + "src": "49987:5:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "50000:6:0", + "nodeType": "YulLiteral", + "src": "50000:6:0", + "type": "", + "value": "0x03c0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "49994:5:0", + "nodeType": "YulIdentifier", + "src": "49994:5:0" + }, + "nativeSrc": "49994:13:0", + "nodeType": "YulFunctionCall", + "src": "49994:13:0" + }, + { + "name": "r", + "nativeSrc": "50009:1:0", + "nodeType": "YulIdentifier", + "src": "50009:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "49980:6:0", + "nodeType": "YulIdentifier", + "src": "49980:6:0" + }, + "nativeSrc": "49980:31:0", + "nodeType": "YulFunctionCall", + "src": "49980:31:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "49971:5:0", + "nodeType": "YulIdentifier", + "src": "49971:5:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "50039:4:0", + "nodeType": "YulLiteral", + "src": "50039:4:0", + "type": "", + "value": "0xa0" + }, + { + "name": "coeff", + "nativeSrc": "50045:5:0", + "nodeType": "YulIdentifier", + "src": "50045:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "50032:6:0", + "nodeType": "YulIdentifier", + "src": "50032:6:0" + }, + "nativeSrc": "50032:19:0", + "nodeType": "YulFunctionCall", + "src": "50032:19:0" + }, + "nativeSrc": "50032:19:0", + "nodeType": "YulExpressionStatement", + "src": "50032:19:0" + }, + { + "nativeSrc": "50072:44:0", + "nodeType": "YulAssignment", + "src": "50072:44:0", + "value": { + "arguments": [ + { + "name": "point_3", + "nativeSrc": "50088:7:0", + "nodeType": "YulIdentifier", + "src": "50088:7:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "50101:1:0", + "nodeType": "YulIdentifier", + "src": "50101:1:0" + }, + { + "name": "point_0", + "nativeSrc": "50104:7:0", + "nodeType": "YulIdentifier", + "src": "50104:7:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "50097:3:0", + "nodeType": "YulIdentifier", + "src": "50097:3:0" + }, + "nativeSrc": "50097:15:0", + "nodeType": "YulFunctionCall", + "src": "50097:15:0" + }, + { + "name": "r", + "nativeSrc": "50114:1:0", + "nodeType": "YulIdentifier", + "src": "50114:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "50081:6:0", + "nodeType": "YulIdentifier", + "src": "50081:6:0" + }, + "nativeSrc": "50081:35:0", + "nodeType": "YulFunctionCall", + "src": "50081:35:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "50072:5:0", + "nodeType": "YulIdentifier", + "src": "50072:5:0" + } + ] + }, + { + "nativeSrc": "50137:62:0", + "nodeType": "YulAssignment", + "src": "50137:62:0", + "value": { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "50153:5:0", + "nodeType": "YulIdentifier", + "src": "50153:5:0" + }, + { + "arguments": [ + { + "name": "point_3", + "nativeSrc": "50167:7:0", + "nodeType": "YulIdentifier", + "src": "50167:7:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "50180:1:0", + "nodeType": "YulIdentifier", + "src": "50180:1:0" + }, + { + "name": "point_2", + "nativeSrc": "50183:7:0", + "nodeType": "YulIdentifier", + "src": "50183:7:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "50176:3:0", + "nodeType": "YulIdentifier", + "src": "50176:3:0" + }, + "nativeSrc": "50176:15:0", + "nodeType": "YulFunctionCall", + "src": "50176:15:0" + }, + { + "name": "r", + "nativeSrc": "50193:1:0", + "nodeType": "YulIdentifier", + "src": "50193:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "50160:6:0", + "nodeType": "YulIdentifier", + "src": "50160:6:0" + }, + "nativeSrc": "50160:35:0", + "nodeType": "YulFunctionCall", + "src": "50160:35:0" + }, + { + "name": "r", + "nativeSrc": "50197:1:0", + "nodeType": "YulIdentifier", + "src": "50197:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "50146:6:0", + "nodeType": "YulIdentifier", + "src": "50146:6:0" + }, + "nativeSrc": "50146:53:0", + "nodeType": "YulFunctionCall", + "src": "50146:53:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "50137:5:0", + "nodeType": "YulIdentifier", + "src": "50137:5:0" + } + ] + }, + { + "nativeSrc": "50220:40:0", + "nodeType": "YulAssignment", + "src": "50220:40:0", + "value": { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "50236:5:0", + "nodeType": "YulIdentifier", + "src": "50236:5:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "50249:6:0", + "nodeType": "YulLiteral", + "src": "50249:6:0", + "type": "", + "value": "0x03e0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "50243:5:0", + "nodeType": "YulIdentifier", + "src": "50243:5:0" + }, + "nativeSrc": "50243:13:0", + "nodeType": "YulFunctionCall", + "src": "50243:13:0" + }, + { + "name": "r", + "nativeSrc": "50258:1:0", + "nodeType": "YulIdentifier", + "src": "50258:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "50229:6:0", + "nodeType": "YulIdentifier", + "src": "50229:6:0" + }, + "nativeSrc": "50229:31:0", + "nodeType": "YulFunctionCall", + "src": "50229:31:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "50220:5:0", + "nodeType": "YulIdentifier", + "src": "50220:5:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "50288:4:0", + "nodeType": "YulLiteral", + "src": "50288:4:0", + "type": "", + "value": "0xc0" + }, + { + "name": "coeff", + "nativeSrc": "50294:5:0", + "nodeType": "YulIdentifier", + "src": "50294:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "50281:6:0", + "nodeType": "YulIdentifier", + "src": "50281:6:0" + }, + "nativeSrc": "50281:19:0", + "nodeType": "YulFunctionCall", + "src": "50281:19:0" + }, + "nativeSrc": "50281:19:0", + "nodeType": "YulExpressionStatement", + "src": "50281:19:0" + } + ] + }, + { + "nativeSrc": "50335:481:0", + "nodeType": "YulBlock", + "src": "50335:481:0", + "statements": [ + { + "nativeSrc": "50357:28:0", + "nodeType": "YulVariableDeclaration", + "src": "50357:28:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "50378:6:0", + "nodeType": "YulLiteral", + "src": "50378:6:0", + "type": "", + "value": "0x0340" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "50372:5:0", + "nodeType": "YulIdentifier", + "src": "50372:5:0" + }, + "nativeSrc": "50372:13:0", + "nodeType": "YulFunctionCall", + "src": "50372:13:0" + }, + "variables": [ + { + "name": "point_2", + "nativeSrc": "50361:7:0", + "nodeType": "YulTypedName", + "src": "50361:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "50406:28:0", + "nodeType": "YulVariableDeclaration", + "src": "50406:28:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "50427:6:0", + "nodeType": "YulLiteral", + "src": "50427:6:0", + "type": "", + "value": "0x0360" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "50421:5:0", + "nodeType": "YulIdentifier", + "src": "50421:5:0" + }, + "nativeSrc": "50421:13:0", + "nodeType": "YulFunctionCall", + "src": "50421:13:0" + }, + "variables": [ + { + "name": "point_3", + "nativeSrc": "50410:7:0", + "nodeType": "YulTypedName", + "src": "50410:7:0", + "type": "" + } + ] + }, + { + "nativeSrc": "50455:9:0", + "nodeType": "YulVariableDeclaration", + "src": "50455:9:0", + "variables": [ + { + "name": "coeff", + "nativeSrc": "50459:5:0", + "nodeType": "YulTypedName", + "src": "50459:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "50485:44:0", + "nodeType": "YulAssignment", + "src": "50485:44:0", + "value": { + "arguments": [ + { + "name": "point_2", + "nativeSrc": "50501:7:0", + "nodeType": "YulIdentifier", + "src": "50501:7:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "50514:1:0", + "nodeType": "YulIdentifier", + "src": "50514:1:0" + }, + { + "name": "point_3", + "nativeSrc": "50517:7:0", + "nodeType": "YulIdentifier", + "src": "50517:7:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "50510:3:0", + "nodeType": "YulIdentifier", + "src": "50510:3:0" + }, + "nativeSrc": "50510:15:0", + "nodeType": "YulFunctionCall", + "src": "50510:15:0" + }, + { + "name": "r", + "nativeSrc": "50527:1:0", + "nodeType": "YulIdentifier", + "src": "50527:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "50494:6:0", + "nodeType": "YulIdentifier", + "src": "50494:6:0" + }, + "nativeSrc": "50494:35:0", + "nodeType": "YulFunctionCall", + "src": "50494:35:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "50485:5:0", + "nodeType": "YulIdentifier", + "src": "50485:5:0" + } + ] + }, + { + "nativeSrc": "50550:40:0", + "nodeType": "YulAssignment", + "src": "50550:40:0", + "value": { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "50566:5:0", + "nodeType": "YulIdentifier", + "src": "50566:5:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "50579:6:0", + "nodeType": "YulLiteral", + "src": "50579:6:0", + "type": "", + "value": "0x03c0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "50573:5:0", + "nodeType": "YulIdentifier", + "src": "50573:5:0" + }, + "nativeSrc": "50573:13:0", + "nodeType": "YulFunctionCall", + "src": "50573:13:0" + }, + { + "name": "r", + "nativeSrc": "50588:1:0", + "nodeType": "YulIdentifier", + "src": "50588:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "50559:6:0", + "nodeType": "YulIdentifier", + "src": "50559:6:0" + }, + "nativeSrc": "50559:31:0", + "nodeType": "YulFunctionCall", + "src": "50559:31:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "50550:5:0", + "nodeType": "YulIdentifier", + "src": "50550:5:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "50618:4:0", + "nodeType": "YulLiteral", + "src": "50618:4:0", + "type": "", + "value": "0xe0" + }, + { + "name": "coeff", + "nativeSrc": "50624:5:0", + "nodeType": "YulIdentifier", + "src": "50624:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "50611:6:0", + "nodeType": "YulIdentifier", + "src": "50611:6:0" + }, + "nativeSrc": "50611:19:0", + "nodeType": "YulFunctionCall", + "src": "50611:19:0" + }, + "nativeSrc": "50611:19:0", + "nodeType": "YulExpressionStatement", + "src": "50611:19:0" + }, + { + "nativeSrc": "50651:44:0", + "nodeType": "YulAssignment", + "src": "50651:44:0", + "value": { + "arguments": [ + { + "name": "point_3", + "nativeSrc": "50667:7:0", + "nodeType": "YulIdentifier", + "src": "50667:7:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "50680:1:0", + "nodeType": "YulIdentifier", + "src": "50680:1:0" + }, + { + "name": "point_2", + "nativeSrc": "50683:7:0", + "nodeType": "YulIdentifier", + "src": "50683:7:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "50676:3:0", + "nodeType": "YulIdentifier", + "src": "50676:3:0" + }, + "nativeSrc": "50676:15:0", + "nodeType": "YulFunctionCall", + "src": "50676:15:0" + }, + { + "name": "r", + "nativeSrc": "50693:1:0", + "nodeType": "YulIdentifier", + "src": "50693:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "50660:6:0", + "nodeType": "YulIdentifier", + "src": "50660:6:0" + }, + "nativeSrc": "50660:35:0", + "nodeType": "YulFunctionCall", + "src": "50660:35:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "50651:5:0", + "nodeType": "YulIdentifier", + "src": "50651:5:0" + } + ] + }, + { + "nativeSrc": "50716:40:0", + "nodeType": "YulAssignment", + "src": "50716:40:0", + "value": { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "50732:5:0", + "nodeType": "YulIdentifier", + "src": "50732:5:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "50745:6:0", + "nodeType": "YulLiteral", + "src": "50745:6:0", + "type": "", + "value": "0x03e0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "50739:5:0", + "nodeType": "YulIdentifier", + "src": "50739:5:0" + }, + "nativeSrc": "50739:13:0", + "nodeType": "YulFunctionCall", + "src": "50739:13:0" + }, + { + "name": "r", + "nativeSrc": "50754:1:0", + "nodeType": "YulIdentifier", + "src": "50754:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "50725:6:0", + "nodeType": "YulIdentifier", + "src": "50725:6:0" + }, + "nativeSrc": "50725:31:0", + "nodeType": "YulFunctionCall", + "src": "50725:31:0" + }, + "variableNames": [ + { + "name": "coeff", + "nativeSrc": "50716:5:0", + "nodeType": "YulIdentifier", + "src": "50716:5:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "50784:6:0", + "nodeType": "YulLiteral", + "src": "50784:6:0", + "type": "", + "value": "0x0100" + }, + { + "name": "coeff", + "nativeSrc": "50792:5:0", + "nodeType": "YulIdentifier", + "src": "50792:5:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "50777:6:0", + "nodeType": "YulIdentifier", + "src": "50777:6:0" + }, + "nativeSrc": "50777:21:0", + "nodeType": "YulFunctionCall", + "src": "50777:21:0" + }, + "nativeSrc": "50777:21:0", + "nodeType": "YulExpressionStatement", + "src": "50777:21:0" + } + ] + }, + { + "nativeSrc": "50833:569:0", + "nodeType": "YulBlock", + "src": "50833:569:0", + "statements": [ + { + "nativeSrc": "50855:46:0", + "nodeType": "YulAssignment", + "src": "50855:46:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "50879:7:0", + "nodeType": "YulIdentifier", + "src": "50879:7:0" + }, + { + "kind": "number", + "nativeSrc": "50888:1:0", + "nodeType": "YulLiteral", + "src": "50888:1:0", + "type": "", + "value": "0" + }, + { + "kind": "number", + "nativeSrc": "50891:6:0", + "nodeType": "YulLiteral", + "src": "50891:6:0", + "type": "", + "value": "0x0120" + }, + { + "name": "r", + "nativeSrc": "50899:1:0", + "nodeType": "YulIdentifier", + "src": "50899:1:0" + } + ], + "functionName": { + "name": "batch_invert", + "nativeSrc": "50866:12:0", + "nodeType": "YulIdentifier", + "src": "50866:12:0" + }, + "nativeSrc": "50866:35:0", + "nodeType": "YulFunctionCall", + "src": "50866:35:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "50855:7:0", + "nodeType": "YulIdentifier", + "src": "50855:7:0" + } + ] + }, + { + "nativeSrc": "50922:29:0", + "nodeType": "YulVariableDeclaration", + "src": "50922:29:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "50946:4:0", + "nodeType": "YulLiteral", + "src": "50946:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "50940:5:0", + "nodeType": "YulIdentifier", + "src": "50940:5:0" + }, + "nativeSrc": "50940:11:0", + "nodeType": "YulFunctionCall", + "src": "50940:11:0" + }, + "variables": [ + { + "name": "diff_0_inv", + "nativeSrc": "50926:10:0", + "nodeType": "YulTypedName", + "src": "50926:10:0", + "type": "" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "50979:6:0", + "nodeType": "YulLiteral", + "src": "50979:6:0", + "type": "", + "value": "0x0420" + }, + { + "name": "diff_0_inv", + "nativeSrc": "50987:10:0", + "nodeType": "YulIdentifier", + "src": "50987:10:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "50972:6:0", + "nodeType": "YulIdentifier", + "src": "50972:6:0" + }, + "nativeSrc": "50972:26:0", + "nodeType": "YulFunctionCall", + "src": "50972:26:0" + }, + "nativeSrc": "50972:26:0", + "nodeType": "YulExpressionStatement", + "src": "50972:26:0" + }, + { + "body": { + "nativeSrc": "51288:96:0", + "nodeType": "YulBlock", + "src": "51288:96:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "51321:4:0", + "nodeType": "YulIdentifier", + "src": "51321:4:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "51340:4:0", + "nodeType": "YulIdentifier", + "src": "51340:4:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "51334:5:0", + "nodeType": "YulIdentifier", + "src": "51334:5:0" + }, + "nativeSrc": "51334:11:0", + "nodeType": "YulFunctionCall", + "src": "51334:11:0" + }, + { + "name": "diff_0_inv", + "nativeSrc": "51347:10:0", + "nodeType": "YulIdentifier", + "src": "51347:10:0" + }, + { + "name": "r", + "nativeSrc": "51359:1:0", + "nodeType": "YulIdentifier", + "src": "51359:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "51327:6:0", + "nodeType": "YulIdentifier", + "src": "51327:6:0" + }, + "nativeSrc": "51327:34:0", + "nodeType": "YulFunctionCall", + "src": "51327:34:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "51314:6:0", + "nodeType": "YulIdentifier", + "src": "51314:6:0" + }, + "nativeSrc": "51314:48:0", + "nodeType": "YulFunctionCall", + "src": "51314:48:0" + }, + "nativeSrc": "51314:48:0", + "nodeType": "YulExpressionStatement", + "src": "51314:48:0" + } + ] + }, + "condition": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "51200:4:0", + "nodeType": "YulIdentifier", + "src": "51200:4:0" + }, + { + "name": "mptr_end", + "nativeSrc": "51206:8:0", + "nodeType": "YulIdentifier", + "src": "51206:8:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "51197:2:0", + "nodeType": "YulIdentifier", + "src": "51197:2:0" + }, + "nativeSrc": "51197:18:0", + "nodeType": "YulFunctionCall", + "src": "51197:18:0" + }, + "nativeSrc": "51019:365:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "51240:27:0", + "nodeType": "YulBlock", + "src": "51240:27:0", + "statements": [ + { + "nativeSrc": "51242:23:0", + "nodeType": "YulAssignment", + "src": "51242:23:0", + "value": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "51254:4:0", + "nodeType": "YulIdentifier", + "src": "51254:4:0" + }, + { + "kind": "number", + "nativeSrc": "51260:4:0", + "nodeType": "YulLiteral", + "src": "51260:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "51250:3:0", + "nodeType": "YulIdentifier", + "src": "51250:3:0" + }, + "nativeSrc": "51250:15:0", + "nodeType": "YulFunctionCall", + "src": "51250:15:0" + }, + "variableNames": [ + { + "name": "mptr", + "nativeSrc": "51242:4:0", + "nodeType": "YulIdentifier", + "src": "51242:4:0" + } + ] + } + ] + }, + "pre": { + "nativeSrc": "51047:125:0", + "nodeType": "YulBlock", + "src": "51047:125:0", + "statements": [ + { + "nativeSrc": "51077:18:0", + "nodeType": "YulVariableDeclaration", + "src": "51077:18:0", + "value": { + "kind": "number", + "nativeSrc": "51089:6:0", + "nodeType": "YulLiteral", + "src": "51089:6:0", + "type": "", + "value": "0x0440" + }, + "variables": [ + { + "name": "mptr", + "nativeSrc": "51081:4:0", + "nodeType": "YulTypedName", + "src": "51081:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "51124:22:0", + "nodeType": "YulVariableDeclaration", + "src": "51124:22:0", + "value": { + "kind": "number", + "nativeSrc": "51140:6:0", + "nodeType": "YulLiteral", + "src": "51140:6:0", + "type": "", + "value": "0x04a0" + }, + "variables": [ + { + "name": "mptr_end", + "nativeSrc": "51128:8:0", + "nodeType": "YulTypedName", + "src": "51128:8:0", + "type": "" + } + ] + } + ] + }, + "src": "51019:365:0" + } + ] + }, + { + "nativeSrc": "51419:1977:0", + "nodeType": "YulBlock", + "src": "51419:1977:0", + "statements": [ + { + "nativeSrc": "51441:24:0", + "nodeType": "YulVariableDeclaration", + "src": "51441:24:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "51460:4:0", + "nodeType": "YulLiteral", + "src": "51460:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "51454:5:0", + "nodeType": "YulIdentifier", + "src": "51454:5:0" + }, + "nativeSrc": "51454:11:0", + "nodeType": "YulFunctionCall", + "src": "51454:11:0" + }, + "variables": [ + { + "name": "coeff", + "nativeSrc": "51445:5:0", + "nodeType": "YulTypedName", + "src": "51445:5:0", + "type": "" + } + ] + }, + { + "nativeSrc": "51486:28:0", + "nodeType": "YulVariableDeclaration", + "src": "51486:28:0", + "value": { + "arguments": [ + { + "name": "ZETA_MPTR", + "nativeSrc": "51504:9:0", + "nodeType": "YulIdentifier", + "src": "51504:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "51498:5:0", + "nodeType": "YulIdentifier", + "src": "51498:5:0" + }, + "nativeSrc": "51498:16:0", + "nodeType": "YulFunctionCall", + "src": "51498:16:0" + }, + "variables": [ + { + "name": "zeta", + "nativeSrc": "51490:4:0", + "nodeType": "YulTypedName", + "src": "51490:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "51535:15:0", + "nodeType": "YulVariableDeclaration", + "src": "51535:15:0", + "value": { + "kind": "number", + "nativeSrc": "51549:1:0", + "nodeType": "YulLiteral", + "src": "51549:1:0", + "type": "", + "value": "0" + }, + "variables": [ + { + "name": "r_eval", + "nativeSrc": "51539:6:0", + "nodeType": "YulTypedName", + "src": "51539:6:0", + "type": "" + } + ] + }, + { + "nativeSrc": "51571:67:0", + "nodeType": "YulAssignment", + "src": "51571:67:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "51588:6:0", + "nodeType": "YulIdentifier", + "src": "51588:6:0" + }, + { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "51603:5:0", + "nodeType": "YulIdentifier", + "src": "51603:5:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "51623:6:0", + "nodeType": "YulLiteral", + "src": "51623:6:0", + "type": "", + "value": "0x0664" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "51610:12:0", + "nodeType": "YulIdentifier", + "src": "51610:12:0" + }, + "nativeSrc": "51610:20:0", + "nodeType": "YulFunctionCall", + "src": "51610:20:0" + }, + { + "name": "r", + "nativeSrc": "51632:1:0", + "nodeType": "YulIdentifier", + "src": "51632:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "51596:6:0", + "nodeType": "YulIdentifier", + "src": "51596:6:0" + }, + "nativeSrc": "51596:38:0", + "nodeType": "YulFunctionCall", + "src": "51596:38:0" + }, + { + "name": "r", + "nativeSrc": "51636:1:0", + "nodeType": "YulIdentifier", + "src": "51636:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "51581:6:0", + "nodeType": "YulIdentifier", + "src": "51581:6:0" + }, + "nativeSrc": "51581:57:0", + "nodeType": "YulFunctionCall", + "src": "51581:57:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "51571:6:0", + "nodeType": "YulIdentifier", + "src": "51571:6:0" + } + ] + }, + { + "nativeSrc": "51659:33:0", + "nodeType": "YulAssignment", + "src": "51659:33:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "51676:6:0", + "nodeType": "YulIdentifier", + "src": "51676:6:0" + }, + { + "name": "zeta", + "nativeSrc": "51684:4:0", + "nodeType": "YulIdentifier", + "src": "51684:4:0" + }, + { + "name": "r", + "nativeSrc": "51690:1:0", + "nodeType": "YulIdentifier", + "src": "51690:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "51669:6:0", + "nodeType": "YulIdentifier", + "src": "51669:6:0" + }, + "nativeSrc": "51669:23:0", + "nodeType": "YulFunctionCall", + "src": "51669:23:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "51659:6:0", + "nodeType": "YulIdentifier", + "src": "51659:6:0" + } + ] + }, + { + "nativeSrc": "51713:72:0", + "nodeType": "YulAssignment", + "src": "51713:72:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "51730:6:0", + "nodeType": "YulIdentifier", + "src": "51730:6:0" + }, + { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "51745:5:0", + "nodeType": "YulIdentifier", + "src": "51745:5:0" + }, + { + "arguments": [ + { + "name": "QUOTIENT_EVAL_MPTR", + "nativeSrc": "51758:18:0", + "nodeType": "YulIdentifier", + "src": "51758:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "51752:5:0", + "nodeType": "YulIdentifier", + "src": "51752:5:0" + }, + "nativeSrc": "51752:25:0", + "nodeType": "YulFunctionCall", + "src": "51752:25:0" + }, + { + "name": "r", + "nativeSrc": "51779:1:0", + "nodeType": "YulIdentifier", + "src": "51779:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "51738:6:0", + "nodeType": "YulIdentifier", + "src": "51738:6:0" + }, + "nativeSrc": "51738:43:0", + "nodeType": "YulFunctionCall", + "src": "51738:43:0" + }, + { + "name": "r", + "nativeSrc": "51783:1:0", + "nodeType": "YulIdentifier", + "src": "51783:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "51723:6:0", + "nodeType": "YulIdentifier", + "src": "51723:6:0" + }, + "nativeSrc": "51723:62:0", + "nodeType": "YulFunctionCall", + "src": "51723:62:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "51713:6:0", + "nodeType": "YulIdentifier", + "src": "51713:6:0" + } + ] + }, + { + "body": { + "nativeSrc": "52075:130:0", + "nodeType": "YulBlock", + "src": "52075:130:0", + "statements": [ + { + "nativeSrc": "52101:82:0", + "nodeType": "YulAssignment", + "src": "52101:82:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "52125:6:0", + "nodeType": "YulIdentifier", + "src": "52125:6:0" + }, + { + "name": "zeta", + "nativeSrc": "52133:4:0", + "nodeType": "YulIdentifier", + "src": "52133:4:0" + }, + { + "name": "r", + "nativeSrc": "52139:1:0", + "nodeType": "YulIdentifier", + "src": "52139:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "52118:6:0", + "nodeType": "YulIdentifier", + "src": "52118:6:0" + }, + "nativeSrc": "52118:23:0", + "nodeType": "YulFunctionCall", + "src": "52118:23:0" + }, + { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "52150:5:0", + "nodeType": "YulIdentifier", + "src": "52150:5:0" + }, + { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "52170:4:0", + "nodeType": "YulIdentifier", + "src": "52170:4:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "52157:12:0", + "nodeType": "YulIdentifier", + "src": "52157:12:0" + }, + "nativeSrc": "52157:18:0", + "nodeType": "YulFunctionCall", + "src": "52157:18:0" + }, + { + "name": "r", + "nativeSrc": "52177:1:0", + "nodeType": "YulIdentifier", + "src": "52177:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "52143:6:0", + "nodeType": "YulIdentifier", + "src": "52143:6:0" + }, + "nativeSrc": "52143:36:0", + "nodeType": "YulFunctionCall", + "src": "52143:36:0" + }, + { + "name": "r", + "nativeSrc": "52181:1:0", + "nodeType": "YulIdentifier", + "src": "52181:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "52111:6:0", + "nodeType": "YulIdentifier", + "src": "52111:6:0" + }, + "nativeSrc": "52111:72:0", + "nodeType": "YulFunctionCall", + "src": "52111:72:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "52101:6:0", + "nodeType": "YulIdentifier", + "src": "52101:6:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "mptr_end", + "nativeSrc": "51987:8:0", + "nodeType": "YulIdentifier", + "src": "51987:8:0" + }, + { + "name": "mptr", + "nativeSrc": "51997:4:0", + "nodeType": "YulIdentifier", + "src": "51997:4:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "51984:2:0", + "nodeType": "YulIdentifier", + "src": "51984:2:0" + }, + "nativeSrc": "51984:18:0", + "nodeType": "YulFunctionCall", + "src": "51984:18:0" + }, + "nativeSrc": "51806:399:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "52027:27:0", + "nodeType": "YulBlock", + "src": "52027:27:0", + "statements": [ + { + "nativeSrc": "52029:23:0", + "nodeType": "YulAssignment", + "src": "52029:23:0", + "value": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "52041:4:0", + "nodeType": "YulIdentifier", + "src": "52041:4:0" + }, + { + "kind": "number", + "nativeSrc": "52047:4:0", + "nodeType": "YulLiteral", + "src": "52047:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "52037:3:0", + "nodeType": "YulIdentifier", + "src": "52037:3:0" + }, + "nativeSrc": "52037:15:0", + "nodeType": "YulFunctionCall", + "src": "52037:15:0" + }, + "variableNames": [ + { + "name": "mptr", + "nativeSrc": "52029:4:0", + "nodeType": "YulIdentifier", + "src": "52029:4:0" + } + ] + } + ] + }, + "pre": { + "nativeSrc": "51834:125:0", + "nodeType": "YulBlock", + "src": "51834:125:0", + "statements": [ + { + "nativeSrc": "51864:18:0", + "nodeType": "YulVariableDeclaration", + "src": "51864:18:0", + "value": { + "kind": "number", + "nativeSrc": "51876:6:0", + "nodeType": "YulLiteral", + "src": "51876:6:0", + "type": "", + "value": "0x0704" + }, + "variables": [ + { + "name": "mptr", + "nativeSrc": "51868:4:0", + "nodeType": "YulTypedName", + "src": "51868:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "51911:22:0", + "nodeType": "YulVariableDeclaration", + "src": "51911:22:0", + "value": { + "kind": "number", + "nativeSrc": "51927:6:0", + "nodeType": "YulLiteral", + "src": "51927:6:0", + "type": "", + "value": "0x0664" + }, + "variables": [ + { + "name": "mptr_end", + "nativeSrc": "51915:8:0", + "nodeType": "YulTypedName", + "src": "51915:8:0", + "type": "" + } + ] + } + ] + }, + "src": "51806:399:0" + }, + { + "body": { + "nativeSrc": "52495:130:0", + "nodeType": "YulBlock", + "src": "52495:130:0", + "statements": [ + { + "nativeSrc": "52521:82:0", + "nodeType": "YulAssignment", + "src": "52521:82:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "52545:6:0", + "nodeType": "YulIdentifier", + "src": "52545:6:0" + }, + { + "name": "zeta", + "nativeSrc": "52553:4:0", + "nodeType": "YulIdentifier", + "src": "52553:4:0" + }, + { + "name": "r", + "nativeSrc": "52559:1:0", + "nodeType": "YulIdentifier", + "src": "52559:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "52538:6:0", + "nodeType": "YulIdentifier", + "src": "52538:6:0" + }, + "nativeSrc": "52538:23:0", + "nodeType": "YulFunctionCall", + "src": "52538:23:0" + }, + { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "52570:5:0", + "nodeType": "YulIdentifier", + "src": "52570:5:0" + }, + { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "52590:4:0", + "nodeType": "YulIdentifier", + "src": "52590:4:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "52577:12:0", + "nodeType": "YulIdentifier", + "src": "52577:12:0" + }, + "nativeSrc": "52577:18:0", + "nodeType": "YulFunctionCall", + "src": "52577:18:0" + }, + { + "name": "r", + "nativeSrc": "52597:1:0", + "nodeType": "YulIdentifier", + "src": "52597:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "52563:6:0", + "nodeType": "YulIdentifier", + "src": "52563:6:0" + }, + "nativeSrc": "52563:36:0", + "nodeType": "YulFunctionCall", + "src": "52563:36:0" + }, + { + "name": "r", + "nativeSrc": "52601:1:0", + "nodeType": "YulIdentifier", + "src": "52601:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "52531:6:0", + "nodeType": "YulIdentifier", + "src": "52531:6:0" + }, + "nativeSrc": "52531:72:0", + "nodeType": "YulFunctionCall", + "src": "52531:72:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "52521:6:0", + "nodeType": "YulIdentifier", + "src": "52521:6:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "mptr_end", + "nativeSrc": "52407:8:0", + "nodeType": "YulIdentifier", + "src": "52407:8:0" + }, + { + "name": "mptr", + "nativeSrc": "52417:4:0", + "nodeType": "YulIdentifier", + "src": "52417:4:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "52404:2:0", + "nodeType": "YulIdentifier", + "src": "52404:2:0" + }, + "nativeSrc": "52404:18:0", + "nodeType": "YulFunctionCall", + "src": "52404:18:0" + }, + "nativeSrc": "52226:399:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "52447:27:0", + "nodeType": "YulBlock", + "src": "52447:27:0", + "statements": [ + { + "nativeSrc": "52449:23:0", + "nodeType": "YulAssignment", + "src": "52449:23:0", + "value": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "52461:4:0", + "nodeType": "YulIdentifier", + "src": "52461:4:0" + }, + { + "kind": "number", + "nativeSrc": "52467:4:0", + "nodeType": "YulLiteral", + "src": "52467:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "52457:3:0", + "nodeType": "YulIdentifier", + "src": "52457:3:0" + }, + "nativeSrc": "52457:15:0", + "nodeType": "YulFunctionCall", + "src": "52457:15:0" + }, + "variableNames": [ + { + "name": "mptr", + "nativeSrc": "52449:4:0", + "nodeType": "YulIdentifier", + "src": "52449:4:0" + } + ] + } + ] + }, + "pre": { + "nativeSrc": "52254:125:0", + "nodeType": "YulBlock", + "src": "52254:125:0", + "statements": [ + { + "nativeSrc": "52284:18:0", + "nodeType": "YulVariableDeclaration", + "src": "52284:18:0", + "value": { + "kind": "number", + "nativeSrc": "52296:6:0", + "nodeType": "YulLiteral", + "src": "52296:6:0", + "type": "", + "value": "0x0644" + }, + "variables": [ + { + "name": "mptr", + "nativeSrc": "52288:4:0", + "nodeType": "YulTypedName", + "src": "52288:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "52331:22:0", + "nodeType": "YulVariableDeclaration", + "src": "52331:22:0", + "value": { + "kind": "number", + "nativeSrc": "52347:6:0", + "nodeType": "YulLiteral", + "src": "52347:6:0", + "type": "", + "value": "0x04c4" + }, + "variables": [ + { + "name": "mptr_end", + "nativeSrc": "52335:8:0", + "nodeType": "YulTypedName", + "src": "52335:8:0", + "type": "" + } + ] + } + ] + }, + "src": "52226:399:0" + }, + { + "nativeSrc": "52646:33:0", + "nodeType": "YulAssignment", + "src": "52646:33:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "52663:6:0", + "nodeType": "YulIdentifier", + "src": "52663:6:0" + }, + { + "name": "zeta", + "nativeSrc": "52671:4:0", + "nodeType": "YulIdentifier", + "src": "52671:4:0" + }, + { + "name": "r", + "nativeSrc": "52677:1:0", + "nodeType": "YulIdentifier", + "src": "52677:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "52656:6:0", + "nodeType": "YulIdentifier", + "src": "52656:6:0" + }, + "nativeSrc": "52656:23:0", + "nodeType": "YulFunctionCall", + "src": "52656:23:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "52646:6:0", + "nodeType": "YulIdentifier", + "src": "52646:6:0" + } + ] + }, + { + "nativeSrc": "52700:67:0", + "nodeType": "YulAssignment", + "src": "52700:67:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "52717:6:0", + "nodeType": "YulIdentifier", + "src": "52717:6:0" + }, + { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "52732:5:0", + "nodeType": "YulIdentifier", + "src": "52732:5:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "52752:6:0", + "nodeType": "YulLiteral", + "src": "52752:6:0", + "type": "", + "value": "0x08c4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "52739:12:0", + "nodeType": "YulIdentifier", + "src": "52739:12:0" + }, + "nativeSrc": "52739:20:0", + "nodeType": "YulFunctionCall", + "src": "52739:20:0" + }, + { + "name": "r", + "nativeSrc": "52761:1:0", + "nodeType": "YulIdentifier", + "src": "52761:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "52725:6:0", + "nodeType": "YulIdentifier", + "src": "52725:6:0" + }, + "nativeSrc": "52725:38:0", + "nodeType": "YulFunctionCall", + "src": "52725:38:0" + }, + { + "name": "r", + "nativeSrc": "52765:1:0", + "nodeType": "YulIdentifier", + "src": "52765:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "52710:6:0", + "nodeType": "YulIdentifier", + "src": "52710:6:0" + }, + "nativeSrc": "52710:57:0", + "nodeType": "YulFunctionCall", + "src": "52710:57:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "52700:6:0", + "nodeType": "YulIdentifier", + "src": "52700:6:0" + } + ] + }, + { + "nativeSrc": "52788:33:0", + "nodeType": "YulAssignment", + "src": "52788:33:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "52805:6:0", + "nodeType": "YulIdentifier", + "src": "52805:6:0" + }, + { + "name": "zeta", + "nativeSrc": "52813:4:0", + "nodeType": "YulIdentifier", + "src": "52813:4:0" + }, + { + "name": "r", + "nativeSrc": "52819:1:0", + "nodeType": "YulIdentifier", + "src": "52819:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "52798:6:0", + "nodeType": "YulIdentifier", + "src": "52798:6:0" + }, + "nativeSrc": "52798:23:0", + "nodeType": "YulFunctionCall", + "src": "52798:23:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "52788:6:0", + "nodeType": "YulIdentifier", + "src": "52788:6:0" + } + ] + }, + { + "nativeSrc": "52842:67:0", + "nodeType": "YulAssignment", + "src": "52842:67:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "52859:6:0", + "nodeType": "YulIdentifier", + "src": "52859:6:0" + }, + { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "52874:5:0", + "nodeType": "YulIdentifier", + "src": "52874:5:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "52894:6:0", + "nodeType": "YulLiteral", + "src": "52894:6:0", + "type": "", + "value": "0x0864" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "52881:12:0", + "nodeType": "YulIdentifier", + "src": "52881:12:0" + }, + "nativeSrc": "52881:20:0", + "nodeType": "YulFunctionCall", + "src": "52881:20:0" + }, + { + "name": "r", + "nativeSrc": "52903:1:0", + "nodeType": "YulIdentifier", + "src": "52903:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "52867:6:0", + "nodeType": "YulIdentifier", + "src": "52867:6:0" + }, + "nativeSrc": "52867:38:0", + "nodeType": "YulFunctionCall", + "src": "52867:38:0" + }, + { + "name": "r", + "nativeSrc": "52907:1:0", + "nodeType": "YulIdentifier", + "src": "52907:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "52852:6:0", + "nodeType": "YulIdentifier", + "src": "52852:6:0" + }, + "nativeSrc": "52852:57:0", + "nodeType": "YulFunctionCall", + "src": "52852:57:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "52842:6:0", + "nodeType": "YulIdentifier", + "src": "52842:6:0" + } + ] + }, + { + "nativeSrc": "52930:33:0", + "nodeType": "YulAssignment", + "src": "52930:33:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "52947:6:0", + "nodeType": "YulIdentifier", + "src": "52947:6:0" + }, + { + "name": "zeta", + "nativeSrc": "52955:4:0", + "nodeType": "YulIdentifier", + "src": "52955:4:0" + }, + { + "name": "r", + "nativeSrc": "52961:1:0", + "nodeType": "YulIdentifier", + "src": "52961:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "52940:6:0", + "nodeType": "YulIdentifier", + "src": "52940:6:0" + }, + "nativeSrc": "52940:23:0", + "nodeType": "YulFunctionCall", + "src": "52940:23:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "52930:6:0", + "nodeType": "YulIdentifier", + "src": "52930:6:0" + } + ] + }, + { + "nativeSrc": "52984:67:0", + "nodeType": "YulAssignment", + "src": "52984:67:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "53001:6:0", + "nodeType": "YulIdentifier", + "src": "53001:6:0" + }, + { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "53016:5:0", + "nodeType": "YulIdentifier", + "src": "53016:5:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "53036:6:0", + "nodeType": "YulLiteral", + "src": "53036:6:0", + "type": "", + "value": "0x0804" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "53023:12:0", + "nodeType": "YulIdentifier", + "src": "53023:12:0" + }, + "nativeSrc": "53023:20:0", + "nodeType": "YulFunctionCall", + "src": "53023:20:0" + }, + { + "name": "r", + "nativeSrc": "53045:1:0", + "nodeType": "YulIdentifier", + "src": "53045:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "53009:6:0", + "nodeType": "YulIdentifier", + "src": "53009:6:0" + }, + "nativeSrc": "53009:38:0", + "nodeType": "YulFunctionCall", + "src": "53009:38:0" + }, + { + "name": "r", + "nativeSrc": "53049:1:0", + "nodeType": "YulIdentifier", + "src": "53049:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "52994:6:0", + "nodeType": "YulIdentifier", + "src": "52994:6:0" + }, + "nativeSrc": "52994:57:0", + "nodeType": "YulFunctionCall", + "src": "52994:57:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "52984:6:0", + "nodeType": "YulIdentifier", + "src": "52984:6:0" + } + ] + }, + { + "nativeSrc": "53072:33:0", + "nodeType": "YulAssignment", + "src": "53072:33:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "53089:6:0", + "nodeType": "YulIdentifier", + "src": "53089:6:0" + }, + { + "name": "zeta", + "nativeSrc": "53097:4:0", + "nodeType": "YulIdentifier", + "src": "53097:4:0" + }, + { + "name": "r", + "nativeSrc": "53103:1:0", + "nodeType": "YulIdentifier", + "src": "53103:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "53082:6:0", + "nodeType": "YulIdentifier", + "src": "53082:6:0" + }, + "nativeSrc": "53082:23:0", + "nodeType": "YulFunctionCall", + "src": "53082:23:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "53072:6:0", + "nodeType": "YulIdentifier", + "src": "53072:6:0" + } + ] + }, + { + "nativeSrc": "53126:67:0", + "nodeType": "YulAssignment", + "src": "53126:67:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "53143:6:0", + "nodeType": "YulIdentifier", + "src": "53143:6:0" + }, + { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "53158:5:0", + "nodeType": "YulIdentifier", + "src": "53158:5:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "53178:6:0", + "nodeType": "YulLiteral", + "src": "53178:6:0", + "type": "", + "value": "0x0484" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "53165:12:0", + "nodeType": "YulIdentifier", + "src": "53165:12:0" + }, + "nativeSrc": "53165:20:0", + "nodeType": "YulFunctionCall", + "src": "53165:20:0" + }, + { + "name": "r", + "nativeSrc": "53187:1:0", + "nodeType": "YulIdentifier", + "src": "53187:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "53151:6:0", + "nodeType": "YulIdentifier", + "src": "53151:6:0" + }, + "nativeSrc": "53151:38:0", + "nodeType": "YulFunctionCall", + "src": "53151:38:0" + }, + { + "name": "r", + "nativeSrc": "53191:1:0", + "nodeType": "YulIdentifier", + "src": "53191:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "53136:6:0", + "nodeType": "YulIdentifier", + "src": "53136:6:0" + }, + "nativeSrc": "53136:57:0", + "nodeType": "YulFunctionCall", + "src": "53136:57:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "53126:6:0", + "nodeType": "YulIdentifier", + "src": "53126:6:0" + } + ] + }, + { + "nativeSrc": "53214:33:0", + "nodeType": "YulAssignment", + "src": "53214:33:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "53231:6:0", + "nodeType": "YulIdentifier", + "src": "53231:6:0" + }, + { + "name": "zeta", + "nativeSrc": "53239:4:0", + "nodeType": "YulIdentifier", + "src": "53239:4:0" + }, + { + "name": "r", + "nativeSrc": "53245:1:0", + "nodeType": "YulIdentifier", + "src": "53245:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "53224:6:0", + "nodeType": "YulIdentifier", + "src": "53224:6:0" + }, + "nativeSrc": "53224:23:0", + "nodeType": "YulFunctionCall", + "src": "53224:23:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "53214:6:0", + "nodeType": "YulIdentifier", + "src": "53214:6:0" + } + ] + }, + { + "nativeSrc": "53268:67:0", + "nodeType": "YulAssignment", + "src": "53268:67:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "53285:6:0", + "nodeType": "YulIdentifier", + "src": "53285:6:0" + }, + { + "arguments": [ + { + "name": "coeff", + "nativeSrc": "53300:5:0", + "nodeType": "YulIdentifier", + "src": "53300:5:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "53320:6:0", + "nodeType": "YulLiteral", + "src": "53320:6:0", + "type": "", + "value": "0x0464" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "53307:12:0", + "nodeType": "YulIdentifier", + "src": "53307:12:0" + }, + "nativeSrc": "53307:20:0", + "nodeType": "YulFunctionCall", + "src": "53307:20:0" + }, + { + "name": "r", + "nativeSrc": "53329:1:0", + "nodeType": "YulIdentifier", + "src": "53329:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "53293:6:0", + "nodeType": "YulIdentifier", + "src": "53293:6:0" + }, + "nativeSrc": "53293:38:0", + "nodeType": "YulFunctionCall", + "src": "53293:38:0" + }, + { + "name": "r", + "nativeSrc": "53333:1:0", + "nodeType": "YulIdentifier", + "src": "53333:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "53278:6:0", + "nodeType": "YulIdentifier", + "src": "53278:6:0" + }, + "nativeSrc": "53278:57:0", + "nodeType": "YulFunctionCall", + "src": "53278:57:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "53268:6:0", + "nodeType": "YulIdentifier", + "src": "53268:6:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "53363:6:0", + "nodeType": "YulLiteral", + "src": "53363:6:0", + "type": "", + "value": "0x04a0" + }, + { + "name": "r_eval", + "nativeSrc": "53371:6:0", + "nodeType": "YulIdentifier", + "src": "53371:6:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "53356:6:0", + "nodeType": "YulIdentifier", + "src": "53356:6:0" + }, + "nativeSrc": "53356:22:0", + "nodeType": "YulFunctionCall", + "src": "53356:22:0" + }, + "nativeSrc": "53356:22:0", + "nodeType": "YulExpressionStatement", + "src": "53356:22:0" + } + ] + }, + { + "nativeSrc": "53413:398:0", + "nodeType": "YulBlock", + "src": "53413:398:0", + "statements": [ + { + "nativeSrc": "53435:28:0", + "nodeType": "YulVariableDeclaration", + "src": "53435:28:0", + "value": { + "arguments": [ + { + "name": "ZETA_MPTR", + "nativeSrc": "53453:9:0", + "nodeType": "YulIdentifier", + "src": "53453:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "53447:5:0", + "nodeType": "YulIdentifier", + "src": "53447:5:0" + }, + "nativeSrc": "53447:16:0", + "nodeType": "YulFunctionCall", + "src": "53447:16:0" + }, + "variables": [ + { + "name": "zeta", + "nativeSrc": "53439:4:0", + "nodeType": "YulTypedName", + "src": "53439:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "53484:15:0", + "nodeType": "YulVariableDeclaration", + "src": "53484:15:0", + "value": { + "kind": "number", + "nativeSrc": "53498:1:0", + "nodeType": "YulLiteral", + "src": "53498:1:0", + "type": "", + "value": "0" + }, + "variables": [ + { + "name": "r_eval", + "nativeSrc": "53488:6:0", + "nodeType": "YulTypedName", + "src": "53488:6:0", + "type": "" + } + ] + }, + { + "nativeSrc": "53520:73:0", + "nodeType": "YulAssignment", + "src": "53520:73:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "53537:6:0", + "nodeType": "YulIdentifier", + "src": "53537:6:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "53558:4:0", + "nodeType": "YulLiteral", + "src": "53558:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "53552:5:0", + "nodeType": "YulIdentifier", + "src": "53552:5:0" + }, + "nativeSrc": "53552:11:0", + "nodeType": "YulFunctionCall", + "src": "53552:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "53578:6:0", + "nodeType": "YulLiteral", + "src": "53578:6:0", + "type": "", + "value": "0x04c4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "53565:12:0", + "nodeType": "YulIdentifier", + "src": "53565:12:0" + }, + "nativeSrc": "53565:20:0", + "nodeType": "YulFunctionCall", + "src": "53565:20:0" + }, + { + "name": "r", + "nativeSrc": "53587:1:0", + "nodeType": "YulIdentifier", + "src": "53587:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "53545:6:0", + "nodeType": "YulIdentifier", + "src": "53545:6:0" + }, + "nativeSrc": "53545:44:0", + "nodeType": "YulFunctionCall", + "src": "53545:44:0" + }, + { + "name": "r", + "nativeSrc": "53591:1:0", + "nodeType": "YulIdentifier", + "src": "53591:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "53530:6:0", + "nodeType": "YulIdentifier", + "src": "53530:6:0" + }, + "nativeSrc": "53530:63:0", + "nodeType": "YulFunctionCall", + "src": "53530:63:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "53520:6:0", + "nodeType": "YulIdentifier", + "src": "53520:6:0" + } + ] + }, + { + "nativeSrc": "53614:73:0", + "nodeType": "YulAssignment", + "src": "53614:73:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "53631:6:0", + "nodeType": "YulIdentifier", + "src": "53631:6:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "53652:4:0", + "nodeType": "YulLiteral", + "src": "53652:4:0", + "type": "", + "value": "0x60" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "53646:5:0", + "nodeType": "YulIdentifier", + "src": "53646:5:0" + }, + "nativeSrc": "53646:11:0", + "nodeType": "YulFunctionCall", + "src": "53646:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "53672:6:0", + "nodeType": "YulLiteral", + "src": "53672:6:0", + "type": "", + "value": "0x04a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "53659:12:0", + "nodeType": "YulIdentifier", + "src": "53659:12:0" + }, + "nativeSrc": "53659:20:0", + "nodeType": "YulFunctionCall", + "src": "53659:20:0" + }, + { + "name": "r", + "nativeSrc": "53681:1:0", + "nodeType": "YulIdentifier", + "src": "53681:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "53639:6:0", + "nodeType": "YulIdentifier", + "src": "53639:6:0" + }, + "nativeSrc": "53639:44:0", + "nodeType": "YulFunctionCall", + "src": "53639:44:0" + }, + { + "name": "r", + "nativeSrc": "53685:1:0", + "nodeType": "YulIdentifier", + "src": "53685:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "53624:6:0", + "nodeType": "YulIdentifier", + "src": "53624:6:0" + }, + "nativeSrc": "53624:63:0", + "nodeType": "YulFunctionCall", + "src": "53624:63:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "53614:6:0", + "nodeType": "YulIdentifier", + "src": "53614:6:0" + } + ] + }, + { + "nativeSrc": "53708:42:0", + "nodeType": "YulAssignment", + "src": "53708:42:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "53725:6:0", + "nodeType": "YulIdentifier", + "src": "53725:6:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "53739:6:0", + "nodeType": "YulLiteral", + "src": "53739:6:0", + "type": "", + "value": "0x0440" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "53733:5:0", + "nodeType": "YulIdentifier", + "src": "53733:5:0" + }, + "nativeSrc": "53733:13:0", + "nodeType": "YulFunctionCall", + "src": "53733:13:0" + }, + { + "name": "r", + "nativeSrc": "53748:1:0", + "nodeType": "YulIdentifier", + "src": "53748:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "53718:6:0", + "nodeType": "YulIdentifier", + "src": "53718:6:0" + }, + "nativeSrc": "53718:32:0", + "nodeType": "YulFunctionCall", + "src": "53718:32:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "53708:6:0", + "nodeType": "YulIdentifier", + "src": "53708:6:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "53778:6:0", + "nodeType": "YulLiteral", + "src": "53778:6:0", + "type": "", + "value": "0x04c0" + }, + { + "name": "r_eval", + "nativeSrc": "53786:6:0", + "nodeType": "YulIdentifier", + "src": "53786:6:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "53771:6:0", + "nodeType": "YulIdentifier", + "src": "53771:6:0" + }, + "nativeSrc": "53771:22:0", + "nodeType": "YulFunctionCall", + "src": "53771:22:0" + }, + "nativeSrc": "53771:22:0", + "nodeType": "YulExpressionStatement", + "src": "53771:22:0" + } + ] + }, + { + "nativeSrc": "53828:492:0", + "nodeType": "YulBlock", + "src": "53828:492:0", + "statements": [ + { + "nativeSrc": "53850:28:0", + "nodeType": "YulVariableDeclaration", + "src": "53850:28:0", + "value": { + "arguments": [ + { + "name": "ZETA_MPTR", + "nativeSrc": "53868:9:0", + "nodeType": "YulIdentifier", + "src": "53868:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "53862:5:0", + "nodeType": "YulIdentifier", + "src": "53862:5:0" + }, + "nativeSrc": "53862:16:0", + "nodeType": "YulFunctionCall", + "src": "53862:16:0" + }, + "variables": [ + { + "name": "zeta", + "nativeSrc": "53854:4:0", + "nodeType": "YulTypedName", + "src": "53854:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "53899:15:0", + "nodeType": "YulVariableDeclaration", + "src": "53899:15:0", + "value": { + "kind": "number", + "nativeSrc": "53913:1:0", + "nodeType": "YulLiteral", + "src": "53913:1:0", + "type": "", + "value": "0" + }, + "variables": [ + { + "name": "r_eval", + "nativeSrc": "53903:6:0", + "nodeType": "YulTypedName", + "src": "53903:6:0", + "type": "" + } + ] + }, + { + "nativeSrc": "53935:73:0", + "nodeType": "YulAssignment", + "src": "53935:73:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "53952:6:0", + "nodeType": "YulIdentifier", + "src": "53952:6:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "53973:4:0", + "nodeType": "YulLiteral", + "src": "53973:4:0", + "type": "", + "value": "0x80" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "53967:5:0", + "nodeType": "YulIdentifier", + "src": "53967:5:0" + }, + "nativeSrc": "53967:11:0", + "nodeType": "YulFunctionCall", + "src": "53967:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "53993:6:0", + "nodeType": "YulLiteral", + "src": "53993:6:0", + "type": "", + "value": "0x0764" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "53980:12:0", + "nodeType": "YulIdentifier", + "src": "53980:12:0" + }, + "nativeSrc": "53980:20:0", + "nodeType": "YulFunctionCall", + "src": "53980:20:0" + }, + { + "name": "r", + "nativeSrc": "54002:1:0", + "nodeType": "YulIdentifier", + "src": "54002:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "53960:6:0", + "nodeType": "YulIdentifier", + "src": "53960:6:0" + }, + "nativeSrc": "53960:44:0", + "nodeType": "YulFunctionCall", + "src": "53960:44:0" + }, + { + "name": "r", + "nativeSrc": "54006:1:0", + "nodeType": "YulIdentifier", + "src": "54006:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "53945:6:0", + "nodeType": "YulIdentifier", + "src": "53945:6:0" + }, + "nativeSrc": "53945:63:0", + "nodeType": "YulFunctionCall", + "src": "53945:63:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "53935:6:0", + "nodeType": "YulIdentifier", + "src": "53935:6:0" + } + ] + }, + { + "nativeSrc": "54029:73:0", + "nodeType": "YulAssignment", + "src": "54029:73:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "54046:6:0", + "nodeType": "YulIdentifier", + "src": "54046:6:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54067:4:0", + "nodeType": "YulLiteral", + "src": "54067:4:0", + "type": "", + "value": "0xa0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "54061:5:0", + "nodeType": "YulIdentifier", + "src": "54061:5:0" + }, + "nativeSrc": "54061:11:0", + "nodeType": "YulFunctionCall", + "src": "54061:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54087:6:0", + "nodeType": "YulLiteral", + "src": "54087:6:0", + "type": "", + "value": "0x0724" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "54074:12:0", + "nodeType": "YulIdentifier", + "src": "54074:12:0" + }, + "nativeSrc": "54074:20:0", + "nodeType": "YulFunctionCall", + "src": "54074:20:0" + }, + { + "name": "r", + "nativeSrc": "54096:1:0", + "nodeType": "YulIdentifier", + "src": "54096:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "54054:6:0", + "nodeType": "YulIdentifier", + "src": "54054:6:0" + }, + "nativeSrc": "54054:44:0", + "nodeType": "YulFunctionCall", + "src": "54054:44:0" + }, + { + "name": "r", + "nativeSrc": "54100:1:0", + "nodeType": "YulIdentifier", + "src": "54100:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "54039:6:0", + "nodeType": "YulIdentifier", + "src": "54039:6:0" + }, + "nativeSrc": "54039:63:0", + "nodeType": "YulFunctionCall", + "src": "54039:63:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "54029:6:0", + "nodeType": "YulIdentifier", + "src": "54029:6:0" + } + ] + }, + { + "nativeSrc": "54123:73:0", + "nodeType": "YulAssignment", + "src": "54123:73:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "54140:6:0", + "nodeType": "YulIdentifier", + "src": "54140:6:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54161:4:0", + "nodeType": "YulLiteral", + "src": "54161:4:0", + "type": "", + "value": "0xc0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "54155:5:0", + "nodeType": "YulIdentifier", + "src": "54155:5:0" + }, + "nativeSrc": "54155:11:0", + "nodeType": "YulFunctionCall", + "src": "54155:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54181:6:0", + "nodeType": "YulLiteral", + "src": "54181:6:0", + "type": "", + "value": "0x0744" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "54168:12:0", + "nodeType": "YulIdentifier", + "src": "54168:12:0" + }, + "nativeSrc": "54168:20:0", + "nodeType": "YulFunctionCall", + "src": "54168:20:0" + }, + { + "name": "r", + "nativeSrc": "54190:1:0", + "nodeType": "YulIdentifier", + "src": "54190:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "54148:6:0", + "nodeType": "YulIdentifier", + "src": "54148:6:0" + }, + "nativeSrc": "54148:44:0", + "nodeType": "YulFunctionCall", + "src": "54148:44:0" + }, + { + "name": "r", + "nativeSrc": "54194:1:0", + "nodeType": "YulIdentifier", + "src": "54194:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "54133:6:0", + "nodeType": "YulIdentifier", + "src": "54133:6:0" + }, + "nativeSrc": "54133:63:0", + "nodeType": "YulFunctionCall", + "src": "54133:63:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "54123:6:0", + "nodeType": "YulIdentifier", + "src": "54123:6:0" + } + ] + }, + { + "nativeSrc": "54217:42:0", + "nodeType": "YulAssignment", + "src": "54217:42:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "54234:6:0", + "nodeType": "YulIdentifier", + "src": "54234:6:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54248:6:0", + "nodeType": "YulLiteral", + "src": "54248:6:0", + "type": "", + "value": "0x0460" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "54242:5:0", + "nodeType": "YulIdentifier", + "src": "54242:5:0" + }, + "nativeSrc": "54242:13:0", + "nodeType": "YulFunctionCall", + "src": "54242:13:0" + }, + { + "name": "r", + "nativeSrc": "54257:1:0", + "nodeType": "YulIdentifier", + "src": "54257:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "54227:6:0", + "nodeType": "YulIdentifier", + "src": "54227:6:0" + }, + "nativeSrc": "54227:32:0", + "nodeType": "YulFunctionCall", + "src": "54227:32:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "54217:6:0", + "nodeType": "YulIdentifier", + "src": "54217:6:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54287:6:0", + "nodeType": "YulLiteral", + "src": "54287:6:0", + "type": "", + "value": "0x04e0" + }, + { + "name": "r_eval", + "nativeSrc": "54295:6:0", + "nodeType": "YulIdentifier", + "src": "54295:6:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "54280:6:0", + "nodeType": "YulIdentifier", + "src": "54280:6:0" + }, + "nativeSrc": "54280:22:0", + "nodeType": "YulFunctionCall", + "src": "54280:22:0" + }, + "nativeSrc": "54280:22:0", + "nodeType": "YulExpressionStatement", + "src": "54280:22:0" + } + ] + }, + { + "nativeSrc": "54337:1132:0", + "nodeType": "YulBlock", + "src": "54337:1132:0", + "statements": [ + { + "nativeSrc": "54359:28:0", + "nodeType": "YulVariableDeclaration", + "src": "54359:28:0", + "value": { + "arguments": [ + { + "name": "ZETA_MPTR", + "nativeSrc": "54377:9:0", + "nodeType": "YulIdentifier", + "src": "54377:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "54371:5:0", + "nodeType": "YulIdentifier", + "src": "54371:5:0" + }, + "nativeSrc": "54371:16:0", + "nodeType": "YulFunctionCall", + "src": "54371:16:0" + }, + "variables": [ + { + "name": "zeta", + "nativeSrc": "54363:4:0", + "nodeType": "YulTypedName", + "src": "54363:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "54408:15:0", + "nodeType": "YulVariableDeclaration", + "src": "54408:15:0", + "value": { + "kind": "number", + "nativeSrc": "54422:1:0", + "nodeType": "YulLiteral", + "src": "54422:1:0", + "type": "", + "value": "0" + }, + "variables": [ + { + "name": "r_eval", + "nativeSrc": "54412:6:0", + "nodeType": "YulTypedName", + "src": "54412:6:0", + "type": "" + } + ] + }, + { + "nativeSrc": "54444:73:0", + "nodeType": "YulAssignment", + "src": "54444:73:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "54461:6:0", + "nodeType": "YulIdentifier", + "src": "54461:6:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54482:4:0", + "nodeType": "YulLiteral", + "src": "54482:4:0", + "type": "", + "value": "0xe0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "54476:5:0", + "nodeType": "YulIdentifier", + "src": "54476:5:0" + }, + "nativeSrc": "54476:11:0", + "nodeType": "YulFunctionCall", + "src": "54476:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54502:6:0", + "nodeType": "YulLiteral", + "src": "54502:6:0", + "type": "", + "value": "0x0884" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "54489:12:0", + "nodeType": "YulIdentifier", + "src": "54489:12:0" + }, + "nativeSrc": "54489:20:0", + "nodeType": "YulFunctionCall", + "src": "54489:20:0" + }, + { + "name": "r", + "nativeSrc": "54511:1:0", + "nodeType": "YulIdentifier", + "src": "54511:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "54469:6:0", + "nodeType": "YulIdentifier", + "src": "54469:6:0" + }, + "nativeSrc": "54469:44:0", + "nodeType": "YulFunctionCall", + "src": "54469:44:0" + }, + { + "name": "r", + "nativeSrc": "54515:1:0", + "nodeType": "YulIdentifier", + "src": "54515:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "54454:6:0", + "nodeType": "YulIdentifier", + "src": "54454:6:0" + }, + "nativeSrc": "54454:63:0", + "nodeType": "YulFunctionCall", + "src": "54454:63:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "54444:6:0", + "nodeType": "YulIdentifier", + "src": "54444:6:0" + } + ] + }, + { + "nativeSrc": "54538:75:0", + "nodeType": "YulAssignment", + "src": "54538:75:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "54555:6:0", + "nodeType": "YulIdentifier", + "src": "54555:6:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54576:6:0", + "nodeType": "YulLiteral", + "src": "54576:6:0", + "type": "", + "value": "0x0100" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "54570:5:0", + "nodeType": "YulIdentifier", + "src": "54570:5:0" + }, + "nativeSrc": "54570:13:0", + "nodeType": "YulFunctionCall", + "src": "54570:13:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54598:6:0", + "nodeType": "YulLiteral", + "src": "54598:6:0", + "type": "", + "value": "0x08a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "54585:12:0", + "nodeType": "YulIdentifier", + "src": "54585:12:0" + }, + "nativeSrc": "54585:20:0", + "nodeType": "YulFunctionCall", + "src": "54585:20:0" + }, + { + "name": "r", + "nativeSrc": "54607:1:0", + "nodeType": "YulIdentifier", + "src": "54607:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "54563:6:0", + "nodeType": "YulIdentifier", + "src": "54563:6:0" + }, + "nativeSrc": "54563:46:0", + "nodeType": "YulFunctionCall", + "src": "54563:46:0" + }, + { + "name": "r", + "nativeSrc": "54611:1:0", + "nodeType": "YulIdentifier", + "src": "54611:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "54548:6:0", + "nodeType": "YulIdentifier", + "src": "54548:6:0" + }, + "nativeSrc": "54548:65:0", + "nodeType": "YulFunctionCall", + "src": "54548:65:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "54538:6:0", + "nodeType": "YulIdentifier", + "src": "54538:6:0" + } + ] + }, + { + "nativeSrc": "54634:33:0", + "nodeType": "YulAssignment", + "src": "54634:33:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "54651:6:0", + "nodeType": "YulIdentifier", + "src": "54651:6:0" + }, + { + "name": "zeta", + "nativeSrc": "54659:4:0", + "nodeType": "YulIdentifier", + "src": "54659:4:0" + }, + { + "name": "r", + "nativeSrc": "54665:1:0", + "nodeType": "YulIdentifier", + "src": "54665:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "54644:6:0", + "nodeType": "YulIdentifier", + "src": "54644:6:0" + }, + "nativeSrc": "54644:23:0", + "nodeType": "YulFunctionCall", + "src": "54644:23:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "54634:6:0", + "nodeType": "YulIdentifier", + "src": "54634:6:0" + } + ] + }, + { + "nativeSrc": "54688:73:0", + "nodeType": "YulAssignment", + "src": "54688:73:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "54705:6:0", + "nodeType": "YulIdentifier", + "src": "54705:6:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54726:4:0", + "nodeType": "YulLiteral", + "src": "54726:4:0", + "type": "", + "value": "0xe0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "54720:5:0", + "nodeType": "YulIdentifier", + "src": "54720:5:0" + }, + "nativeSrc": "54720:11:0", + "nodeType": "YulFunctionCall", + "src": "54720:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54746:6:0", + "nodeType": "YulLiteral", + "src": "54746:6:0", + "type": "", + "value": "0x0824" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "54733:12:0", + "nodeType": "YulIdentifier", + "src": "54733:12:0" + }, + "nativeSrc": "54733:20:0", + "nodeType": "YulFunctionCall", + "src": "54733:20:0" + }, + { + "name": "r", + "nativeSrc": "54755:1:0", + "nodeType": "YulIdentifier", + "src": "54755:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "54713:6:0", + "nodeType": "YulIdentifier", + "src": "54713:6:0" + }, + "nativeSrc": "54713:44:0", + "nodeType": "YulFunctionCall", + "src": "54713:44:0" + }, + { + "name": "r", + "nativeSrc": "54759:1:0", + "nodeType": "YulIdentifier", + "src": "54759:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "54698:6:0", + "nodeType": "YulIdentifier", + "src": "54698:6:0" + }, + "nativeSrc": "54698:63:0", + "nodeType": "YulFunctionCall", + "src": "54698:63:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "54688:6:0", + "nodeType": "YulIdentifier", + "src": "54688:6:0" + } + ] + }, + { + "nativeSrc": "54782:75:0", + "nodeType": "YulAssignment", + "src": "54782:75:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "54799:6:0", + "nodeType": "YulIdentifier", + "src": "54799:6:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54820:6:0", + "nodeType": "YulLiteral", + "src": "54820:6:0", + "type": "", + "value": "0x0100" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "54814:5:0", + "nodeType": "YulIdentifier", + "src": "54814:5:0" + }, + "nativeSrc": "54814:13:0", + "nodeType": "YulFunctionCall", + "src": "54814:13:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54842:6:0", + "nodeType": "YulLiteral", + "src": "54842:6:0", + "type": "", + "value": "0x0844" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "54829:12:0", + "nodeType": "YulIdentifier", + "src": "54829:12:0" + }, + "nativeSrc": "54829:20:0", + "nodeType": "YulFunctionCall", + "src": "54829:20:0" + }, + { + "name": "r", + "nativeSrc": "54851:1:0", + "nodeType": "YulIdentifier", + "src": "54851:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "54807:6:0", + "nodeType": "YulIdentifier", + "src": "54807:6:0" + }, + "nativeSrc": "54807:46:0", + "nodeType": "YulFunctionCall", + "src": "54807:46:0" + }, + { + "name": "r", + "nativeSrc": "54855:1:0", + "nodeType": "YulIdentifier", + "src": "54855:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "54792:6:0", + "nodeType": "YulIdentifier", + "src": "54792:6:0" + }, + "nativeSrc": "54792:65:0", + "nodeType": "YulFunctionCall", + "src": "54792:65:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "54782:6:0", + "nodeType": "YulIdentifier", + "src": "54782:6:0" + } + ] + }, + { + "nativeSrc": "54878:33:0", + "nodeType": "YulAssignment", + "src": "54878:33:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "54895:6:0", + "nodeType": "YulIdentifier", + "src": "54895:6:0" + }, + { + "name": "zeta", + "nativeSrc": "54903:4:0", + "nodeType": "YulIdentifier", + "src": "54903:4:0" + }, + { + "name": "r", + "nativeSrc": "54909:1:0", + "nodeType": "YulIdentifier", + "src": "54909:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "54888:6:0", + "nodeType": "YulIdentifier", + "src": "54888:6:0" + }, + "nativeSrc": "54888:23:0", + "nodeType": "YulFunctionCall", + "src": "54888:23:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "54878:6:0", + "nodeType": "YulIdentifier", + "src": "54878:6:0" + } + ] + }, + { + "nativeSrc": "54932:73:0", + "nodeType": "YulAssignment", + "src": "54932:73:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "54949:6:0", + "nodeType": "YulIdentifier", + "src": "54949:6:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54970:4:0", + "nodeType": "YulLiteral", + "src": "54970:4:0", + "type": "", + "value": "0xe0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "54964:5:0", + "nodeType": "YulIdentifier", + "src": "54964:5:0" + }, + "nativeSrc": "54964:11:0", + "nodeType": "YulFunctionCall", + "src": "54964:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "54990:6:0", + "nodeType": "YulLiteral", + "src": "54990:6:0", + "type": "", + "value": "0x07c4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "54977:12:0", + "nodeType": "YulIdentifier", + "src": "54977:12:0" + }, + "nativeSrc": "54977:20:0", + "nodeType": "YulFunctionCall", + "src": "54977:20:0" + }, + { + "name": "r", + "nativeSrc": "54999:1:0", + "nodeType": "YulIdentifier", + "src": "54999:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "54957:6:0", + "nodeType": "YulIdentifier", + "src": "54957:6:0" + }, + "nativeSrc": "54957:44:0", + "nodeType": "YulFunctionCall", + "src": "54957:44:0" + }, + { + "name": "r", + "nativeSrc": "55003:1:0", + "nodeType": "YulIdentifier", + "src": "55003:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "54942:6:0", + "nodeType": "YulIdentifier", + "src": "54942:6:0" + }, + "nativeSrc": "54942:63:0", + "nodeType": "YulFunctionCall", + "src": "54942:63:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "54932:6:0", + "nodeType": "YulIdentifier", + "src": "54932:6:0" + } + ] + }, + { + "nativeSrc": "55026:75:0", + "nodeType": "YulAssignment", + "src": "55026:75:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "55043:6:0", + "nodeType": "YulIdentifier", + "src": "55043:6:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55064:6:0", + "nodeType": "YulLiteral", + "src": "55064:6:0", + "type": "", + "value": "0x0100" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "55058:5:0", + "nodeType": "YulIdentifier", + "src": "55058:5:0" + }, + "nativeSrc": "55058:13:0", + "nodeType": "YulFunctionCall", + "src": "55058:13:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55086:6:0", + "nodeType": "YulLiteral", + "src": "55086:6:0", + "type": "", + "value": "0x07e4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "55073:12:0", + "nodeType": "YulIdentifier", + "src": "55073:12:0" + }, + "nativeSrc": "55073:20:0", + "nodeType": "YulFunctionCall", + "src": "55073:20:0" + }, + { + "name": "r", + "nativeSrc": "55095:1:0", + "nodeType": "YulIdentifier", + "src": "55095:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "55051:6:0", + "nodeType": "YulIdentifier", + "src": "55051:6:0" + }, + "nativeSrc": "55051:46:0", + "nodeType": "YulFunctionCall", + "src": "55051:46:0" + }, + { + "name": "r", + "nativeSrc": "55099:1:0", + "nodeType": "YulIdentifier", + "src": "55099:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "55036:6:0", + "nodeType": "YulIdentifier", + "src": "55036:6:0" + }, + "nativeSrc": "55036:65:0", + "nodeType": "YulFunctionCall", + "src": "55036:65:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "55026:6:0", + "nodeType": "YulIdentifier", + "src": "55026:6:0" + } + ] + }, + { + "nativeSrc": "55122:33:0", + "nodeType": "YulAssignment", + "src": "55122:33:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "55139:6:0", + "nodeType": "YulIdentifier", + "src": "55139:6:0" + }, + { + "name": "zeta", + "nativeSrc": "55147:4:0", + "nodeType": "YulIdentifier", + "src": "55147:4:0" + }, + { + "name": "r", + "nativeSrc": "55153:1:0", + "nodeType": "YulIdentifier", + "src": "55153:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "55132:6:0", + "nodeType": "YulIdentifier", + "src": "55132:6:0" + }, + "nativeSrc": "55132:23:0", + "nodeType": "YulFunctionCall", + "src": "55132:23:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "55122:6:0", + "nodeType": "YulIdentifier", + "src": "55122:6:0" + } + ] + }, + { + "nativeSrc": "55176:73:0", + "nodeType": "YulAssignment", + "src": "55176:73:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "55193:6:0", + "nodeType": "YulIdentifier", + "src": "55193:6:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55214:4:0", + "nodeType": "YulLiteral", + "src": "55214:4:0", + "type": "", + "value": "0xe0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "55208:5:0", + "nodeType": "YulIdentifier", + "src": "55208:5:0" + }, + "nativeSrc": "55208:11:0", + "nodeType": "YulFunctionCall", + "src": "55208:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55234:6:0", + "nodeType": "YulLiteral", + "src": "55234:6:0", + "type": "", + "value": "0x0784" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "55221:12:0", + "nodeType": "YulIdentifier", + "src": "55221:12:0" + }, + "nativeSrc": "55221:20:0", + "nodeType": "YulFunctionCall", + "src": "55221:20:0" + }, + { + "name": "r", + "nativeSrc": "55243:1:0", + "nodeType": "YulIdentifier", + "src": "55243:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "55201:6:0", + "nodeType": "YulIdentifier", + "src": "55201:6:0" + }, + "nativeSrc": "55201:44:0", + "nodeType": "YulFunctionCall", + "src": "55201:44:0" + }, + { + "name": "r", + "nativeSrc": "55247:1:0", + "nodeType": "YulIdentifier", + "src": "55247:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "55186:6:0", + "nodeType": "YulIdentifier", + "src": "55186:6:0" + }, + "nativeSrc": "55186:63:0", + "nodeType": "YulFunctionCall", + "src": "55186:63:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "55176:6:0", + "nodeType": "YulIdentifier", + "src": "55176:6:0" + } + ] + }, + { + "nativeSrc": "55270:75:0", + "nodeType": "YulAssignment", + "src": "55270:75:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "55287:6:0", + "nodeType": "YulIdentifier", + "src": "55287:6:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55308:6:0", + "nodeType": "YulLiteral", + "src": "55308:6:0", + "type": "", + "value": "0x0100" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "55302:5:0", + "nodeType": "YulIdentifier", + "src": "55302:5:0" + }, + "nativeSrc": "55302:13:0", + "nodeType": "YulFunctionCall", + "src": "55302:13:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55330:6:0", + "nodeType": "YulLiteral", + "src": "55330:6:0", + "type": "", + "value": "0x07a4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "55317:12:0", + "nodeType": "YulIdentifier", + "src": "55317:12:0" + }, + "nativeSrc": "55317:20:0", + "nodeType": "YulFunctionCall", + "src": "55317:20:0" + }, + { + "name": "r", + "nativeSrc": "55339:1:0", + "nodeType": "YulIdentifier", + "src": "55339:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "55295:6:0", + "nodeType": "YulIdentifier", + "src": "55295:6:0" + }, + "nativeSrc": "55295:46:0", + "nodeType": "YulFunctionCall", + "src": "55295:46:0" + }, + { + "name": "r", + "nativeSrc": "55343:1:0", + "nodeType": "YulIdentifier", + "src": "55343:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "55280:6:0", + "nodeType": "YulIdentifier", + "src": "55280:6:0" + }, + "nativeSrc": "55280:65:0", + "nodeType": "YulFunctionCall", + "src": "55280:65:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "55270:6:0", + "nodeType": "YulIdentifier", + "src": "55270:6:0" + } + ] + }, + { + "nativeSrc": "55366:42:0", + "nodeType": "YulAssignment", + "src": "55366:42:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "55383:6:0", + "nodeType": "YulIdentifier", + "src": "55383:6:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55397:6:0", + "nodeType": "YulLiteral", + "src": "55397:6:0", + "type": "", + "value": "0x0480" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "55391:5:0", + "nodeType": "YulIdentifier", + "src": "55391:5:0" + }, + "nativeSrc": "55391:13:0", + "nodeType": "YulFunctionCall", + "src": "55391:13:0" + }, + { + "name": "r", + "nativeSrc": "55406:1:0", + "nodeType": "YulIdentifier", + "src": "55406:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "55376:6:0", + "nodeType": "YulIdentifier", + "src": "55376:6:0" + }, + "nativeSrc": "55376:32:0", + "nodeType": "YulFunctionCall", + "src": "55376:32:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "55366:6:0", + "nodeType": "YulIdentifier", + "src": "55366:6:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55436:6:0", + "nodeType": "YulLiteral", + "src": "55436:6:0", + "type": "", + "value": "0x0500" + }, + { + "name": "r_eval", + "nativeSrc": "55444:6:0", + "nodeType": "YulIdentifier", + "src": "55444:6:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "55429:6:0", + "nodeType": "YulIdentifier", + "src": "55429:6:0" + }, + "nativeSrc": "55429:22:0", + "nodeType": "YulFunctionCall", + "src": "55429:22:0" + }, + "nativeSrc": "55429:22:0", + "nodeType": "YulExpressionStatement", + "src": "55429:22:0" + } + ] + }, + { + "nativeSrc": "55486:102:0", + "nodeType": "YulBlock", + "src": "55486:102:0", + "statements": [ + { + "nativeSrc": "55508:22:0", + "nodeType": "YulVariableDeclaration", + "src": "55508:22:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55525:4:0", + "nodeType": "YulLiteral", + "src": "55525:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "55519:5:0", + "nodeType": "YulIdentifier", + "src": "55519:5:0" + }, + "nativeSrc": "55519:11:0", + "nodeType": "YulFunctionCall", + "src": "55519:11:0" + }, + "variables": [ + { + "name": "sum", + "nativeSrc": "55512:3:0", + "nodeType": "YulTypedName", + "src": "55512:3:0", + "type": "" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55558:6:0", + "nodeType": "YulLiteral", + "src": "55558:6:0", + "type": "", + "value": "0x0520" + }, + { + "name": "sum", + "nativeSrc": "55566:3:0", + "nodeType": "YulIdentifier", + "src": "55566:3:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "55551:6:0", + "nodeType": "YulIdentifier", + "src": "55551:6:0" + }, + "nativeSrc": "55551:19:0", + "nodeType": "YulFunctionCall", + "src": "55551:19:0" + }, + "nativeSrc": "55551:19:0", + "nodeType": "YulExpressionStatement", + "src": "55551:19:0" + } + ] + }, + { + "nativeSrc": "55605:157:0", + "nodeType": "YulBlock", + "src": "55605:157:0", + "statements": [ + { + "nativeSrc": "55627:22:0", + "nodeType": "YulVariableDeclaration", + "src": "55627:22:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55644:4:0", + "nodeType": "YulLiteral", + "src": "55644:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "55638:5:0", + "nodeType": "YulIdentifier", + "src": "55638:5:0" + }, + "nativeSrc": "55638:11:0", + "nodeType": "YulFunctionCall", + "src": "55638:11:0" + }, + "variables": [ + { + "name": "sum", + "nativeSrc": "55631:3:0", + "nodeType": "YulTypedName", + "src": "55631:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "55670:34:0", + "nodeType": "YulAssignment", + "src": "55670:34:0", + "value": { + "arguments": [ + { + "name": "sum", + "nativeSrc": "55684:3:0", + "nodeType": "YulIdentifier", + "src": "55684:3:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55695:4:0", + "nodeType": "YulLiteral", + "src": "55695:4:0", + "type": "", + "value": "0x60" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "55689:5:0", + "nodeType": "YulIdentifier", + "src": "55689:5:0" + }, + "nativeSrc": "55689:11:0", + "nodeType": "YulFunctionCall", + "src": "55689:11:0" + }, + { + "name": "r", + "nativeSrc": "55702:1:0", + "nodeType": "YulIdentifier", + "src": "55702:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "55677:6:0", + "nodeType": "YulIdentifier", + "src": "55677:6:0" + }, + "nativeSrc": "55677:27:0", + "nodeType": "YulFunctionCall", + "src": "55677:27:0" + }, + "variableNames": [ + { + "name": "sum", + "nativeSrc": "55670:3:0", + "nodeType": "YulIdentifier", + "src": "55670:3:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55732:6:0", + "nodeType": "YulLiteral", + "src": "55732:6:0", + "type": "", + "value": "0x0540" + }, + { + "name": "sum", + "nativeSrc": "55740:3:0", + "nodeType": "YulIdentifier", + "src": "55740:3:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "55725:6:0", + "nodeType": "YulIdentifier", + "src": "55725:6:0" + }, + "nativeSrc": "55725:19:0", + "nodeType": "YulFunctionCall", + "src": "55725:19:0" + }, + "nativeSrc": "55725:19:0", + "nodeType": "YulExpressionStatement", + "src": "55725:19:0" + } + ] + }, + { + "nativeSrc": "55779:212:0", + "nodeType": "YulBlock", + "src": "55779:212:0", + "statements": [ + { + "nativeSrc": "55801:22:0", + "nodeType": "YulVariableDeclaration", + "src": "55801:22:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55818:4:0", + "nodeType": "YulLiteral", + "src": "55818:4:0", + "type": "", + "value": "0x80" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "55812:5:0", + "nodeType": "YulIdentifier", + "src": "55812:5:0" + }, + "nativeSrc": "55812:11:0", + "nodeType": "YulFunctionCall", + "src": "55812:11:0" + }, + "variables": [ + { + "name": "sum", + "nativeSrc": "55805:3:0", + "nodeType": "YulTypedName", + "src": "55805:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "55844:34:0", + "nodeType": "YulAssignment", + "src": "55844:34:0", + "value": { + "arguments": [ + { + "name": "sum", + "nativeSrc": "55858:3:0", + "nodeType": "YulIdentifier", + "src": "55858:3:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55869:4:0", + "nodeType": "YulLiteral", + "src": "55869:4:0", + "type": "", + "value": "0xa0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "55863:5:0", + "nodeType": "YulIdentifier", + "src": "55863:5:0" + }, + "nativeSrc": "55863:11:0", + "nodeType": "YulFunctionCall", + "src": "55863:11:0" + }, + { + "name": "r", + "nativeSrc": "55876:1:0", + "nodeType": "YulIdentifier", + "src": "55876:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "55851:6:0", + "nodeType": "YulIdentifier", + "src": "55851:6:0" + }, + "nativeSrc": "55851:27:0", + "nodeType": "YulFunctionCall", + "src": "55851:27:0" + }, + "variableNames": [ + { + "name": "sum", + "nativeSrc": "55844:3:0", + "nodeType": "YulIdentifier", + "src": "55844:3:0" + } + ] + }, + { + "nativeSrc": "55899:34:0", + "nodeType": "YulAssignment", + "src": "55899:34:0", + "value": { + "arguments": [ + { + "name": "sum", + "nativeSrc": "55913:3:0", + "nodeType": "YulIdentifier", + "src": "55913:3:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55924:4:0", + "nodeType": "YulLiteral", + "src": "55924:4:0", + "type": "", + "value": "0xc0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "55918:5:0", + "nodeType": "YulIdentifier", + "src": "55918:5:0" + }, + "nativeSrc": "55918:11:0", + "nodeType": "YulFunctionCall", + "src": "55918:11:0" + }, + { + "name": "r", + "nativeSrc": "55931:1:0", + "nodeType": "YulIdentifier", + "src": "55931:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "55906:6:0", + "nodeType": "YulIdentifier", + "src": "55906:6:0" + }, + "nativeSrc": "55906:27:0", + "nodeType": "YulFunctionCall", + "src": "55906:27:0" + }, + "variableNames": [ + { + "name": "sum", + "nativeSrc": "55899:3:0", + "nodeType": "YulIdentifier", + "src": "55899:3:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "55961:6:0", + "nodeType": "YulLiteral", + "src": "55961:6:0", + "type": "", + "value": "0x0560" + }, + { + "name": "sum", + "nativeSrc": "55969:3:0", + "nodeType": "YulIdentifier", + "src": "55969:3:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "55954:6:0", + "nodeType": "YulIdentifier", + "src": "55954:6:0" + }, + "nativeSrc": "55954:19:0", + "nodeType": "YulFunctionCall", + "src": "55954:19:0" + }, + "nativeSrc": "55954:19:0", + "nodeType": "YulExpressionStatement", + "src": "55954:19:0" + } + ] + }, + { + "nativeSrc": "56008:159:0", + "nodeType": "YulBlock", + "src": "56008:159:0", + "statements": [ + { + "nativeSrc": "56030:22:0", + "nodeType": "YulVariableDeclaration", + "src": "56030:22:0", + "value": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "56047:4:0", + "nodeType": "YulLiteral", + "src": "56047:4:0", + "type": "", + "value": "0xe0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "56041:5:0", + "nodeType": "YulIdentifier", + "src": "56041:5:0" + }, + "nativeSrc": "56041:11:0", + "nodeType": "YulFunctionCall", + "src": "56041:11:0" + }, + "variables": [ + { + "name": "sum", + "nativeSrc": "56034:3:0", + "nodeType": "YulTypedName", + "src": "56034:3:0", + "type": "" + } + ] + }, + { + "nativeSrc": "56073:36:0", + "nodeType": "YulAssignment", + "src": "56073:36:0", + "value": { + "arguments": [ + { + "name": "sum", + "nativeSrc": "56087:3:0", + "nodeType": "YulIdentifier", + "src": "56087:3:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "56098:6:0", + "nodeType": "YulLiteral", + "src": "56098:6:0", + "type": "", + "value": "0x0100" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "56092:5:0", + "nodeType": "YulIdentifier", + "src": "56092:5:0" + }, + "nativeSrc": "56092:13:0", + "nodeType": "YulFunctionCall", + "src": "56092:13:0" + }, + { + "name": "r", + "nativeSrc": "56107:1:0", + "nodeType": "YulIdentifier", + "src": "56107:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "56080:6:0", + "nodeType": "YulIdentifier", + "src": "56080:6:0" + }, + "nativeSrc": "56080:29:0", + "nodeType": "YulFunctionCall", + "src": "56080:29:0" + }, + "variableNames": [ + { + "name": "sum", + "nativeSrc": "56073:3:0", + "nodeType": "YulIdentifier", + "src": "56073:3:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "56137:6:0", + "nodeType": "YulLiteral", + "src": "56137:6:0", + "type": "", + "value": "0x0580" + }, + { + "name": "sum", + "nativeSrc": "56145:3:0", + "nodeType": "YulIdentifier", + "src": "56145:3:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "56130:6:0", + "nodeType": "YulIdentifier", + "src": "56130:6:0" + }, + "nativeSrc": "56130:19:0", + "nodeType": "YulFunctionCall", + "src": "56130:19:0" + }, + "nativeSrc": "56130:19:0", + "nodeType": "YulExpressionStatement", + "src": "56130:19:0" + } + ] + }, + { + "nativeSrc": "56184:1431:0", + "nodeType": "YulBlock", + "src": "56184:1431:0", + "statements": [ + { + "body": { + "nativeSrc": "56634:77:0", + "nodeType": "YulBlock", + "src": "56634:77:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "56667:4:0", + "nodeType": "YulIdentifier", + "src": "56667:4:0" + }, + { + "arguments": [ + { + "name": "sum_mptr", + "nativeSrc": "56679:8:0", + "nodeType": "YulIdentifier", + "src": "56679:8:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "56673:5:0", + "nodeType": "YulIdentifier", + "src": "56673:5:0" + }, + "nativeSrc": "56673:15:0", + "nodeType": "YulFunctionCall", + "src": "56673:15:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "56660:6:0", + "nodeType": "YulIdentifier", + "src": "56660:6:0" + }, + "nativeSrc": "56660:29:0", + "nodeType": "YulFunctionCall", + "src": "56660:29:0" + }, + "nativeSrc": "56660:29:0", + "nodeType": "YulExpressionStatement", + "src": "56660:29:0" + } + ] + }, + "condition": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "56434:4:0", + "nodeType": "YulIdentifier", + "src": "56434:4:0" + }, + { + "name": "mptr_end", + "nativeSrc": "56440:8:0", + "nodeType": "YulIdentifier", + "src": "56440:8:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "56431:2:0", + "nodeType": "YulIdentifier", + "src": "56431:2:0" + }, + "nativeSrc": "56431:18:0", + "nodeType": "YulFunctionCall", + "src": "56431:18:0" + }, + "nativeSrc": "56206:505:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "56474:139:0", + "nodeType": "YulBlock", + "src": "56474:139:0", + "statements": [ + { + "nativeSrc": "56504:23:0", + "nodeType": "YulAssignment", + "src": "56504:23:0", + "value": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "56516:4:0", + "nodeType": "YulIdentifier", + "src": "56516:4:0" + }, + { + "kind": "number", + "nativeSrc": "56522:4:0", + "nodeType": "YulLiteral", + "src": "56522:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "56512:3:0", + "nodeType": "YulIdentifier", + "src": "56512:3:0" + }, + "nativeSrc": "56512:15:0", + "nodeType": "YulFunctionCall", + "src": "56512:15:0" + }, + "variableNames": [ + { + "name": "mptr", + "nativeSrc": "56504:4:0", + "nodeType": "YulIdentifier", + "src": "56504:4:0" + } + ] + }, + { + "nativeSrc": "56556:31:0", + "nodeType": "YulAssignment", + "src": "56556:31:0", + "value": { + "arguments": [ + { + "name": "sum_mptr", + "nativeSrc": "56572:8:0", + "nodeType": "YulIdentifier", + "src": "56572:8:0" + }, + { + "kind": "number", + "nativeSrc": "56582:4:0", + "nodeType": "YulLiteral", + "src": "56582:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "56568:3:0", + "nodeType": "YulIdentifier", + "src": "56568:3:0" + }, + "nativeSrc": "56568:19:0", + "nodeType": "YulFunctionCall", + "src": "56568:19:0" + }, + "variableNames": [ + { + "name": "sum_mptr", + "nativeSrc": "56556:8:0", + "nodeType": "YulIdentifier", + "src": "56556:8:0" + } + ] + } + ] + }, + "pre": { + "nativeSrc": "56234:172:0", + "nodeType": "YulBlock", + "src": "56234:172:0", + "statements": [ + { + "nativeSrc": "56264:16:0", + "nodeType": "YulVariableDeclaration", + "src": "56264:16:0", + "value": { + "kind": "number", + "nativeSrc": "56276:4:0", + "nodeType": "YulLiteral", + "src": "56276:4:0", + "type": "", + "value": "0x00" + }, + "variables": [ + { + "name": "mptr", + "nativeSrc": "56268:4:0", + "nodeType": "YulTypedName", + "src": "56268:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "56309:20:0", + "nodeType": "YulVariableDeclaration", + "src": "56309:20:0", + "value": { + "kind": "number", + "nativeSrc": "56325:4:0", + "nodeType": "YulLiteral", + "src": "56325:4:0", + "type": "", + "value": "0x80" + }, + "variables": [ + { + "name": "mptr_end", + "nativeSrc": "56313:8:0", + "nodeType": "YulTypedName", + "src": "56313:8:0", + "type": "" + } + ] + }, + { + "nativeSrc": "56358:22:0", + "nodeType": "YulVariableDeclaration", + "src": "56358:22:0", + "value": { + "kind": "number", + "nativeSrc": "56374:6:0", + "nodeType": "YulLiteral", + "src": "56374:6:0", + "type": "", + "value": "0x0520" + }, + "variables": [ + { + "name": "sum_mptr", + "nativeSrc": "56362:8:0", + "nodeType": "YulTypedName", + "src": "56362:8:0", + "type": "" + } + ] + } + ] + }, + "src": "56206:505:0" + }, + { + "nativeSrc": "56732:44:0", + "nodeType": "YulAssignment", + "src": "56732:44:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "56756:7:0", + "nodeType": "YulIdentifier", + "src": "56756:7:0" + }, + { + "kind": "number", + "nativeSrc": "56765:1:0", + "nodeType": "YulLiteral", + "src": "56765:1:0", + "type": "", + "value": "0" + }, + { + "kind": "number", + "nativeSrc": "56768:4:0", + "nodeType": "YulLiteral", + "src": "56768:4:0", + "type": "", + "value": "0x80" + }, + { + "name": "r", + "nativeSrc": "56774:1:0", + "nodeType": "YulIdentifier", + "src": "56774:1:0" + } + ], + "functionName": { + "name": "batch_invert", + "nativeSrc": "56743:12:0", + "nodeType": "YulIdentifier", + "src": "56743:12:0" + }, + "nativeSrc": "56743:33:0", + "nodeType": "YulFunctionCall", + "src": "56743:33:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "56732:7:0", + "nodeType": "YulIdentifier", + "src": "56732:7:0" + } + ] + }, + { + "nativeSrc": "56797:51:0", + "nodeType": "YulVariableDeclaration", + "src": "56797:51:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "56824:4:0", + "nodeType": "YulLiteral", + "src": "56824:4:0", + "type": "", + "value": "0x60" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "56818:5:0", + "nodeType": "YulIdentifier", + "src": "56818:5:0" + }, + "nativeSrc": "56818:11:0", + "nodeType": "YulFunctionCall", + "src": "56818:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "56837:6:0", + "nodeType": "YulLiteral", + "src": "56837:6:0", + "type": "", + "value": "0x0500" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "56831:5:0", + "nodeType": "YulIdentifier", + "src": "56831:5:0" + }, + "nativeSrc": "56831:13:0", + "nodeType": "YulFunctionCall", + "src": "56831:13:0" + }, + { + "name": "r", + "nativeSrc": "56846:1:0", + "nodeType": "YulIdentifier", + "src": "56846:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "56811:6:0", + "nodeType": "YulIdentifier", + "src": "56811:6:0" + }, + "nativeSrc": "56811:37:0", + "nodeType": "YulFunctionCall", + "src": "56811:37:0" + }, + "variables": [ + { + "name": "r_eval", + "nativeSrc": "56801:6:0", + "nodeType": "YulTypedName", + "src": "56801:6:0", + "type": "" + } + ] + }, + { + "body": { + "nativeSrc": "57354:195:0", + "nodeType": "YulBlock", + "src": "57354:195:0", + "statements": [ + { + "nativeSrc": "57380:43:0", + "nodeType": "YulAssignment", + "src": "57380:43:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "57397:6:0", + "nodeType": "YulIdentifier", + "src": "57397:6:0" + }, + { + "arguments": [ + { + "name": "NU_MPTR", + "nativeSrc": "57411:7:0", + "nodeType": "YulIdentifier", + "src": "57411:7:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "57405:5:0", + "nodeType": "YulIdentifier", + "src": "57405:5:0" + }, + "nativeSrc": "57405:14:0", + "nodeType": "YulFunctionCall", + "src": "57405:14:0" + }, + { + "name": "r", + "nativeSrc": "57421:1:0", + "nodeType": "YulIdentifier", + "src": "57421:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "57390:6:0", + "nodeType": "YulIdentifier", + "src": "57390:6:0" + }, + "nativeSrc": "57390:33:0", + "nodeType": "YulFunctionCall", + "src": "57390:33:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "57380:6:0", + "nodeType": "YulIdentifier", + "src": "57380:6:0" + } + ] + }, + { + "nativeSrc": "57448:79:0", + "nodeType": "YulAssignment", + "src": "57448:79:0", + "value": { + "arguments": [ + { + "name": "r_eval", + "nativeSrc": "57465:6:0", + "nodeType": "YulIdentifier", + "src": "57465:6:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "sum_inv_mptr", + "nativeSrc": "57486:12:0", + "nodeType": "YulIdentifier", + "src": "57486:12:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "57480:5:0", + "nodeType": "YulIdentifier", + "src": "57480:5:0" + }, + "nativeSrc": "57480:19:0", + "nodeType": "YulFunctionCall", + "src": "57480:19:0" + }, + { + "arguments": [ + { + "name": "r_eval_mptr", + "nativeSrc": "57507:11:0", + "nodeType": "YulIdentifier", + "src": "57507:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "57501:5:0", + "nodeType": "YulIdentifier", + "src": "57501:5:0" + }, + "nativeSrc": "57501:18:0", + "nodeType": "YulFunctionCall", + "src": "57501:18:0" + }, + { + "name": "r", + "nativeSrc": "57521:1:0", + "nodeType": "YulIdentifier", + "src": "57521:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "57473:6:0", + "nodeType": "YulIdentifier", + "src": "57473:6:0" + }, + "nativeSrc": "57473:50:0", + "nodeType": "YulFunctionCall", + "src": "57473:50:0" + }, + { + "name": "r", + "nativeSrc": "57525:1:0", + "nodeType": "YulIdentifier", + "src": "57525:1:0" + } + ], + "functionName": { + "name": "addmod", + "nativeSrc": "57458:6:0", + "nodeType": "YulIdentifier", + "src": "57458:6:0" + }, + "nativeSrc": "57458:69:0", + "nodeType": "YulFunctionCall", + "src": "57458:69:0" + }, + "variableNames": [ + { + "name": "r_eval", + "nativeSrc": "57448:6:0", + "nodeType": "YulIdentifier", + "src": "57448:6:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "sum_inv_mptr", + "nativeSrc": "57116:12:0", + "nodeType": "YulIdentifier", + "src": "57116:12:0" + }, + { + "name": "sum_inv_mptr_end", + "nativeSrc": "57130:16:0", + "nodeType": "YulIdentifier", + "src": "57130:16:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "57113:2:0", + "nodeType": "YulIdentifier", + "src": "57113:2:0" + }, + "nativeSrc": "57113:34:0", + "nodeType": "YulFunctionCall", + "src": "57113:34:0" + }, + "nativeSrc": "56869:680:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "57172:161:0", + "nodeType": "YulBlock", + "src": "57172:161:0", + "statements": [ + { + "nativeSrc": "57202:39:0", + "nodeType": "YulAssignment", + "src": "57202:39:0", + "value": { + "arguments": [ + { + "name": "sum_inv_mptr", + "nativeSrc": "57222:12:0", + "nodeType": "YulIdentifier", + "src": "57222:12:0" + }, + { + "kind": "number", + "nativeSrc": "57236:4:0", + "nodeType": "YulLiteral", + "src": "57236:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "57218:3:0", + "nodeType": "YulIdentifier", + "src": "57218:3:0" + }, + "nativeSrc": "57218:23:0", + "nodeType": "YulFunctionCall", + "src": "57218:23:0" + }, + "variableNames": [ + { + "name": "sum_inv_mptr", + "nativeSrc": "57202:12:0", + "nodeType": "YulIdentifier", + "src": "57202:12:0" + } + ] + }, + { + "nativeSrc": "57270:37:0", + "nodeType": "YulAssignment", + "src": "57270:37:0", + "value": { + "arguments": [ + { + "name": "r_eval_mptr", + "nativeSrc": "57289:11:0", + "nodeType": "YulIdentifier", + "src": "57289:11:0" + }, + { + "kind": "number", + "nativeSrc": "57302:4:0", + "nodeType": "YulLiteral", + "src": "57302:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "57285:3:0", + "nodeType": "YulIdentifier", + "src": "57285:3:0" + }, + "nativeSrc": "57285:22:0", + "nodeType": "YulFunctionCall", + "src": "57285:22:0" + }, + "variableNames": [ + { + "name": "r_eval_mptr", + "nativeSrc": "57270:11:0", + "nodeType": "YulIdentifier", + "src": "57270:11:0" + } + ] + } + ] + }, + "pre": { + "nativeSrc": "56897:191:0", + "nodeType": "YulBlock", + "src": "56897:191:0", + "statements": [ + { + "nativeSrc": "56927:24:0", + "nodeType": "YulVariableDeclaration", + "src": "56927:24:0", + "value": { + "kind": "number", + "nativeSrc": "56947:4:0", + "nodeType": "YulLiteral", + "src": "56947:4:0", + "type": "", + "value": "0x40" + }, + "variables": [ + { + "name": "sum_inv_mptr", + "nativeSrc": "56931:12:0", + "nodeType": "YulTypedName", + "src": "56931:12:0", + "type": "" + } + ] + }, + { + "nativeSrc": "56980:28:0", + "nodeType": "YulVariableDeclaration", + "src": "56980:28:0", + "value": { + "kind": "number", + "nativeSrc": "57004:4:0", + "nodeType": "YulLiteral", + "src": "57004:4:0", + "type": "", + "value": "0x80" + }, + "variables": [ + { + "name": "sum_inv_mptr_end", + "nativeSrc": "56984:16:0", + "nodeType": "YulTypedName", + "src": "56984:16:0", + "type": "" + } + ] + }, + { + "nativeSrc": "57037:25:0", + "nodeType": "YulVariableDeclaration", + "src": "57037:25:0", + "value": { + "kind": "number", + "nativeSrc": "57056:6:0", + "nodeType": "YulLiteral", + "src": "57056:6:0", + "type": "", + "value": "0x04e0" + }, + "variables": [ + { + "name": "r_eval_mptr", + "nativeSrc": "57041:11:0", + "nodeType": "YulTypedName", + "src": "57041:11:0", + "type": "" + } + ] + } + ] + }, + "src": "56869:680:0" + }, + { + "expression": { + "arguments": [ + { + "name": "R_EVAL_MPTR", + "nativeSrc": "57577:11:0", + "nodeType": "YulIdentifier", + "src": "57577:11:0" + }, + { + "name": "r_eval", + "nativeSrc": "57590:6:0", + "nodeType": "YulIdentifier", + "src": "57590:6:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "57570:6:0", + "nodeType": "YulIdentifier", + "src": "57570:6:0" + }, + "nativeSrc": "57570:27:0", + "nodeType": "YulFunctionCall", + "src": "57570:27:0" + }, + "nativeSrc": "57570:27:0", + "nodeType": "YulExpressionStatement", + "src": "57570:27:0" + } + ] + }, + { + "nativeSrc": "57632:4067:0", + "nodeType": "YulBlock", + "src": "57632:4067:0", + "statements": [ + { + "nativeSrc": "57654:24:0", + "nodeType": "YulVariableDeclaration", + "src": "57654:24:0", + "value": { + "arguments": [ + { + "name": "NU_MPTR", + "nativeSrc": "57670:7:0", + "nodeType": "YulIdentifier", + "src": "57670:7:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "57664:5:0", + "nodeType": "YulIdentifier", + "src": "57664:5:0" + }, + "nativeSrc": "57664:14:0", + "nodeType": "YulFunctionCall", + "src": "57664:14:0" + }, + "variables": [ + { + "name": "nu", + "nativeSrc": "57658:2:0", + "nodeType": "YulTypedName", + "src": "57658:2:0", + "type": "" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "57706:4:0", + "nodeType": "YulLiteral", + "src": "57706:4:0", + "type": "", + "value": "0x00" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "57725:6:0", + "nodeType": "YulLiteral", + "src": "57725:6:0", + "type": "", + "value": "0x0324" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "57712:12:0", + "nodeType": "YulIdentifier", + "src": "57712:12:0" + }, + "nativeSrc": "57712:20:0", + "nodeType": "YulFunctionCall", + "src": "57712:20:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "57699:6:0", + "nodeType": "YulIdentifier", + "src": "57699:6:0" + }, + "nativeSrc": "57699:34:0", + "nodeType": "YulFunctionCall", + "src": "57699:34:0" + }, + "nativeSrc": "57699:34:0", + "nodeType": "YulExpressionStatement", + "src": "57699:34:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "57761:4:0", + "nodeType": "YulLiteral", + "src": "57761:4:0", + "type": "", + "value": "0x20" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "57780:6:0", + "nodeType": "YulLiteral", + "src": "57780:6:0", + "type": "", + "value": "0x0344" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "57767:12:0", + "nodeType": "YulIdentifier", + "src": "57767:12:0" + }, + "nativeSrc": "57767:20:0", + "nodeType": "YulFunctionCall", + "src": "57767:20:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "57754:6:0", + "nodeType": "YulIdentifier", + "src": "57754:6:0" + }, + "nativeSrc": "57754:34:0", + "nodeType": "YulFunctionCall", + "src": "57754:34:0" + }, + "nativeSrc": "57754:34:0", + "nodeType": "YulExpressionStatement", + "src": "57754:34:0" + }, + { + "nativeSrc": "57809:48:0", + "nodeType": "YulAssignment", + "src": "57809:48:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "57831:7:0", + "nodeType": "YulIdentifier", + "src": "57831:7:0" + }, + { + "arguments": [ + { + "name": "ZETA_MPTR", + "nativeSrc": "57846:9:0", + "nodeType": "YulIdentifier", + "src": "57846:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "57840:5:0", + "nodeType": "YulIdentifier", + "src": "57840:5:0" + }, + "nativeSrc": "57840:16:0", + "nodeType": "YulFunctionCall", + "src": "57840:16:0" + } + ], + "functionName": { + "name": "ec_mul_acc", + "nativeSrc": "57820:10:0", + "nodeType": "YulIdentifier", + "src": "57820:10:0" + }, + "nativeSrc": "57820:37:0", + "nodeType": "YulFunctionCall", + "src": "57820:37:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "57809:7:0", + "nodeType": "YulIdentifier", + "src": "57809:7:0" + } + ] + }, + { + "nativeSrc": "57878:78:0", + "nodeType": "YulAssignment", + "src": "57878:78:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "57900:7:0", + "nodeType": "YulIdentifier", + "src": "57900:7:0" + }, + { + "arguments": [ + { + "name": "QUOTIENT_X_MPTR", + "nativeSrc": "57915:15:0", + "nodeType": "YulIdentifier", + "src": "57915:15:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "57909:5:0", + "nodeType": "YulIdentifier", + "src": "57909:5:0" + }, + "nativeSrc": "57909:22:0", + "nodeType": "YulFunctionCall", + "src": "57909:22:0" + }, + { + "arguments": [ + { + "name": "QUOTIENT_Y_MPTR", + "nativeSrc": "57939:15:0", + "nodeType": "YulIdentifier", + "src": "57939:15:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "57933:5:0", + "nodeType": "YulIdentifier", + "src": "57933:5:0" + }, + "nativeSrc": "57933:22:0", + "nodeType": "YulFunctionCall", + "src": "57933:22:0" + } + ], + "functionName": { + "name": "ec_add_acc", + "nativeSrc": "57889:10:0", + "nodeType": "YulIdentifier", + "src": "57889:10:0" + }, + "nativeSrc": "57889:67:0", + "nodeType": "YulFunctionCall", + "src": "57889:67:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "57878:7:0", + "nodeType": "YulIdentifier", + "src": "57878:7:0" + } + ] + }, + { + "body": { + "nativeSrc": "58246:188:0", + "nodeType": "YulBlock", + "src": "58246:188:0", + "statements": [ + { + "nativeSrc": "58272:48:0", + "nodeType": "YulAssignment", + "src": "58272:48:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "58294:7:0", + "nodeType": "YulIdentifier", + "src": "58294:7:0" + }, + { + "arguments": [ + { + "name": "ZETA_MPTR", + "nativeSrc": "58309:9:0", + "nodeType": "YulIdentifier", + "src": "58309:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "58303:5:0", + "nodeType": "YulIdentifier", + "src": "58303:5:0" + }, + "nativeSrc": "58303:16:0", + "nodeType": "YulFunctionCall", + "src": "58303:16:0" + } + ], + "functionName": { + "name": "ec_mul_acc", + "nativeSrc": "58283:10:0", + "nodeType": "YulIdentifier", + "src": "58283:10:0" + }, + "nativeSrc": "58283:37:0", + "nodeType": "YulFunctionCall", + "src": "58283:37:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "58272:7:0", + "nodeType": "YulIdentifier", + "src": "58272:7:0" + } + ] + }, + { + "nativeSrc": "58345:67:0", + "nodeType": "YulAssignment", + "src": "58345:67:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "58367:7:0", + "nodeType": "YulIdentifier", + "src": "58367:7:0" + }, + { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "58382:4:0", + "nodeType": "YulIdentifier", + "src": "58382:4:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "58376:5:0", + "nodeType": "YulIdentifier", + "src": "58376:5:0" + }, + "nativeSrc": "58376:11:0", + "nodeType": "YulFunctionCall", + "src": "58376:11:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "58399:4:0", + "nodeType": "YulIdentifier", + "src": "58399:4:0" + }, + { + "kind": "number", + "nativeSrc": "58405:4:0", + "nodeType": "YulLiteral", + "src": "58405:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "58395:3:0", + "nodeType": "YulIdentifier", + "src": "58395:3:0" + }, + "nativeSrc": "58395:15:0", + "nodeType": "YulFunctionCall", + "src": "58395:15:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "58389:5:0", + "nodeType": "YulIdentifier", + "src": "58389:5:0" + }, + "nativeSrc": "58389:22:0", + "nodeType": "YulFunctionCall", + "src": "58389:22:0" + } + ], + "functionName": { + "name": "ec_add_acc", + "nativeSrc": "58356:10:0", + "nodeType": "YulIdentifier", + "src": "58356:10:0" + }, + "nativeSrc": "58356:56:0", + "nodeType": "YulFunctionCall", + "src": "58356:56:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "58345:7:0", + "nodeType": "YulIdentifier", + "src": "58345:7:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "mptr_end", + "nativeSrc": "58158:8:0", + "nodeType": "YulIdentifier", + "src": "58158:8:0" + }, + { + "name": "mptr", + "nativeSrc": "58168:4:0", + "nodeType": "YulIdentifier", + "src": "58168:4:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "58155:2:0", + "nodeType": "YulIdentifier", + "src": "58155:2:0" + }, + "nativeSrc": "58155:18:0", + "nodeType": "YulFunctionCall", + "src": "58155:18:0" + }, + "nativeSrc": "57977:457:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "58198:27:0", + "nodeType": "YulBlock", + "src": "58198:27:0", + "statements": [ + { + "nativeSrc": "58200:23:0", + "nodeType": "YulAssignment", + "src": "58200:23:0", + "value": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "58212:4:0", + "nodeType": "YulIdentifier", + "src": "58212:4:0" + }, + { + "kind": "number", + "nativeSrc": "58218:4:0", + "nodeType": "YulLiteral", + "src": "58218:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "58208:3:0", + "nodeType": "YulIdentifier", + "src": "58208:3:0" + }, + "nativeSrc": "58208:15:0", + "nodeType": "YulFunctionCall", + "src": "58208:15:0" + }, + "variableNames": [ + { + "name": "mptr", + "nativeSrc": "58200:4:0", + "nodeType": "YulIdentifier", + "src": "58200:4:0" + } + ] + } + ] + }, + "pre": { + "nativeSrc": "58005:125:0", + "nodeType": "YulBlock", + "src": "58005:125:0", + "statements": [ + { + "nativeSrc": "58035:18:0", + "nodeType": "YulVariableDeclaration", + "src": "58035:18:0", + "value": { + "kind": "number", + "nativeSrc": "58047:6:0", + "nodeType": "YulLiteral", + "src": "58047:6:0", + "type": "", + "value": "0x0c40" + }, + "variables": [ + { + "name": "mptr", + "nativeSrc": "58039:4:0", + "nodeType": "YulTypedName", + "src": "58039:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "58082:22:0", + "nodeType": "YulVariableDeclaration", + "src": "58082:22:0", + "value": { + "kind": "number", + "nativeSrc": "58098:6:0", + "nodeType": "YulLiteral", + "src": "58098:6:0", + "type": "", + "value": "0x0800" + }, + "variables": [ + { + "name": "mptr_end", + "nativeSrc": "58086:8:0", + "nodeType": "YulTypedName", + "src": "58086:8:0", + "type": "" + } + ] + } + ] + }, + "src": "57977:457:0" + }, + { + "body": { + "nativeSrc": "58722:202:0", + "nodeType": "YulBlock", + "src": "58722:202:0", + "statements": [ + { + "nativeSrc": "58748:48:0", + "nodeType": "YulAssignment", + "src": "58748:48:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "58770:7:0", + "nodeType": "YulIdentifier", + "src": "58770:7:0" + }, + { + "arguments": [ + { + "name": "ZETA_MPTR", + "nativeSrc": "58785:9:0", + "nodeType": "YulIdentifier", + "src": "58785:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "58779:5:0", + "nodeType": "YulIdentifier", + "src": "58779:5:0" + }, + "nativeSrc": "58779:16:0", + "nodeType": "YulFunctionCall", + "src": "58779:16:0" + } + ], + "functionName": { + "name": "ec_mul_acc", + "nativeSrc": "58759:10:0", + "nodeType": "YulIdentifier", + "src": "58759:10:0" + }, + "nativeSrc": "58759:37:0", + "nodeType": "YulFunctionCall", + "src": "58759:37:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "58748:7:0", + "nodeType": "YulIdentifier", + "src": "58748:7:0" + } + ] + }, + { + "nativeSrc": "58821:81:0", + "nodeType": "YulAssignment", + "src": "58821:81:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "58843:7:0", + "nodeType": "YulIdentifier", + "src": "58843:7:0" + }, + { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "58865:4:0", + "nodeType": "YulIdentifier", + "src": "58865:4:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "58852:12:0", + "nodeType": "YulIdentifier", + "src": "58852:12:0" + }, + "nativeSrc": "58852:18:0", + "nodeType": "YulFunctionCall", + "src": "58852:18:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "58889:4:0", + "nodeType": "YulIdentifier", + "src": "58889:4:0" + }, + { + "kind": "number", + "nativeSrc": "58895:4:0", + "nodeType": "YulLiteral", + "src": "58895:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "58885:3:0", + "nodeType": "YulIdentifier", + "src": "58885:3:0" + }, + "nativeSrc": "58885:15:0", + "nodeType": "YulFunctionCall", + "src": "58885:15:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "58872:12:0", + "nodeType": "YulIdentifier", + "src": "58872:12:0" + }, + "nativeSrc": "58872:29:0", + "nodeType": "YulFunctionCall", + "src": "58872:29:0" + } + ], + "functionName": { + "name": "ec_add_acc", + "nativeSrc": "58832:10:0", + "nodeType": "YulIdentifier", + "src": "58832:10:0" + }, + "nativeSrc": "58832:70:0", + "nodeType": "YulFunctionCall", + "src": "58832:70:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "58821:7:0", + "nodeType": "YulIdentifier", + "src": "58821:7:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "mptr_end", + "nativeSrc": "58634:8:0", + "nodeType": "YulIdentifier", + "src": "58634:8:0" + }, + { + "name": "mptr", + "nativeSrc": "58644:4:0", + "nodeType": "YulIdentifier", + "src": "58644:4:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "58631:2:0", + "nodeType": "YulIdentifier", + "src": "58631:2:0" + }, + "nativeSrc": "58631:18:0", + "nodeType": "YulFunctionCall", + "src": "58631:18:0" + }, + "nativeSrc": "58455:469:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "58674:27:0", + "nodeType": "YulBlock", + "src": "58674:27:0", + "statements": [ + { + "nativeSrc": "58676:23:0", + "nodeType": "YulAssignment", + "src": "58676:23:0", + "value": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "58688:4:0", + "nodeType": "YulIdentifier", + "src": "58688:4:0" + }, + { + "kind": "number", + "nativeSrc": "58694:4:0", + "nodeType": "YulLiteral", + "src": "58694:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "58684:3:0", + "nodeType": "YulIdentifier", + "src": "58684:3:0" + }, + "nativeSrc": "58684:15:0", + "nodeType": "YulFunctionCall", + "src": "58684:15:0" + }, + "variableNames": [ + { + "name": "mptr", + "nativeSrc": "58676:4:0", + "nodeType": "YulIdentifier", + "src": "58676:4:0" + } + ] + } + ] + }, + "pre": { + "nativeSrc": "58483:123:0", + "nodeType": "YulBlock", + "src": "58483:123:0", + "statements": [ + { + "nativeSrc": "58513:18:0", + "nodeType": "YulVariableDeclaration", + "src": "58513:18:0", + "value": { + "kind": "number", + "nativeSrc": "58525:6:0", + "nodeType": "YulLiteral", + "src": "58525:6:0", + "type": "", + "value": "0x01a4" + }, + "variables": [ + { + "name": "mptr", + "nativeSrc": "58517:4:0", + "nodeType": "YulTypedName", + "src": "58517:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "58560:20:0", + "nodeType": "YulVariableDeclaration", + "src": "58560:20:0", + "value": { + "kind": "number", + "nativeSrc": "58576:4:0", + "nodeType": "YulLiteral", + "src": "58576:4:0", + "type": "", + "value": "0xe4" + }, + "variables": [ + { + "name": "mptr_end", + "nativeSrc": "58564:8:0", + "nodeType": "YulTypedName", + "src": "58564:8:0", + "type": "" + } + ] + } + ] + }, + "src": "58455:469:0" + }, + { + "nativeSrc": "58945:48:0", + "nodeType": "YulAssignment", + "src": "58945:48:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "58967:7:0", + "nodeType": "YulIdentifier", + "src": "58967:7:0" + }, + { + "arguments": [ + { + "name": "ZETA_MPTR", + "nativeSrc": "58982:9:0", + "nodeType": "YulIdentifier", + "src": "58982:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "58976:5:0", + "nodeType": "YulIdentifier", + "src": "58976:5:0" + }, + "nativeSrc": "58976:16:0", + "nodeType": "YulFunctionCall", + "src": "58976:16:0" + } + ], + "functionName": { + "name": "ec_mul_acc", + "nativeSrc": "58956:10:0", + "nodeType": "YulIdentifier", + "src": "58956:10:0" + }, + "nativeSrc": "58956:37:0", + "nodeType": "YulFunctionCall", + "src": "58956:37:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "58945:7:0", + "nodeType": "YulIdentifier", + "src": "58945:7:0" + } + ] + }, + { + "nativeSrc": "59014:70:0", + "nodeType": "YulAssignment", + "src": "59014:70:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "59036:7:0", + "nodeType": "YulIdentifier", + "src": "59036:7:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59058:4:0", + "nodeType": "YulLiteral", + "src": "59058:4:0", + "type": "", + "value": "0xa4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "59045:12:0", + "nodeType": "YulIdentifier", + "src": "59045:12:0" + }, + "nativeSrc": "59045:18:0", + "nodeType": "YulFunctionCall", + "src": "59045:18:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59078:4:0", + "nodeType": "YulLiteral", + "src": "59078:4:0", + "type": "", + "value": "0xc4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "59065:12:0", + "nodeType": "YulIdentifier", + "src": "59065:12:0" + }, + "nativeSrc": "59065:18:0", + "nodeType": "YulFunctionCall", + "src": "59065:18:0" + } + ], + "functionName": { + "name": "ec_add_acc", + "nativeSrc": "59025:10:0", + "nodeType": "YulIdentifier", + "src": "59025:10:0" + }, + "nativeSrc": "59025:59:0", + "nodeType": "YulFunctionCall", + "src": "59025:59:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "59014:7:0", + "nodeType": "YulIdentifier", + "src": "59014:7:0" + } + ] + }, + { + "nativeSrc": "59105:48:0", + "nodeType": "YulAssignment", + "src": "59105:48:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "59127:7:0", + "nodeType": "YulIdentifier", + "src": "59127:7:0" + }, + { + "arguments": [ + { + "name": "ZETA_MPTR", + "nativeSrc": "59142:9:0", + "nodeType": "YulIdentifier", + "src": "59142:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "59136:5:0", + "nodeType": "YulIdentifier", + "src": "59136:5:0" + }, + "nativeSrc": "59136:16:0", + "nodeType": "YulFunctionCall", + "src": "59136:16:0" + } + ], + "functionName": { + "name": "ec_mul_acc", + "nativeSrc": "59116:10:0", + "nodeType": "YulIdentifier", + "src": "59116:10:0" + }, + "nativeSrc": "59116:37:0", + "nodeType": "YulFunctionCall", + "src": "59116:37:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "59105:7:0", + "nodeType": "YulIdentifier", + "src": "59105:7:0" + } + ] + }, + { + "nativeSrc": "59174:70:0", + "nodeType": "YulAssignment", + "src": "59174:70:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "59196:7:0", + "nodeType": "YulIdentifier", + "src": "59196:7:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59218:4:0", + "nodeType": "YulLiteral", + "src": "59218:4:0", + "type": "", + "value": "0x64" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "59205:12:0", + "nodeType": "YulIdentifier", + "src": "59205:12:0" + }, + "nativeSrc": "59205:18:0", + "nodeType": "YulFunctionCall", + "src": "59205:18:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59238:4:0", + "nodeType": "YulLiteral", + "src": "59238:4:0", + "type": "", + "value": "0x84" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "59225:12:0", + "nodeType": "YulIdentifier", + "src": "59225:12:0" + }, + "nativeSrc": "59225:18:0", + "nodeType": "YulFunctionCall", + "src": "59225:18:0" + } + ], + "functionName": { + "name": "ec_add_acc", + "nativeSrc": "59185:10:0", + "nodeType": "YulIdentifier", + "src": "59185:10:0" + }, + "nativeSrc": "59185:59:0", + "nodeType": "YulFunctionCall", + "src": "59185:59:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "59174:7:0", + "nodeType": "YulIdentifier", + "src": "59174:7:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59272:4:0", + "nodeType": "YulLiteral", + "src": "59272:4:0", + "type": "", + "value": "0x80" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59291:4:0", + "nodeType": "YulLiteral", + "src": "59291:4:0", + "type": "", + "value": "0xe4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "59278:12:0", + "nodeType": "YulIdentifier", + "src": "59278:12:0" + }, + "nativeSrc": "59278:18:0", + "nodeType": "YulFunctionCall", + "src": "59278:18:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "59265:6:0", + "nodeType": "YulIdentifier", + "src": "59265:6:0" + }, + "nativeSrc": "59265:32:0", + "nodeType": "YulFunctionCall", + "src": "59265:32:0" + }, + "nativeSrc": "59265:32:0", + "nodeType": "YulExpressionStatement", + "src": "59265:32:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59325:4:0", + "nodeType": "YulLiteral", + "src": "59325:4:0", + "type": "", + "value": "0xa0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59344:6:0", + "nodeType": "YulLiteral", + "src": "59344:6:0", + "type": "", + "value": "0x0104" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "59331:12:0", + "nodeType": "YulIdentifier", + "src": "59331:12:0" + }, + "nativeSrc": "59331:20:0", + "nodeType": "YulFunctionCall", + "src": "59331:20:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "59318:6:0", + "nodeType": "YulIdentifier", + "src": "59318:6:0" + }, + "nativeSrc": "59318:34:0", + "nodeType": "YulFunctionCall", + "src": "59318:34:0" + }, + "nativeSrc": "59318:34:0", + "nodeType": "YulExpressionStatement", + "src": "59318:34:0" + }, + { + "nativeSrc": "59373:60:0", + "nodeType": "YulAssignment", + "src": "59373:60:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "59395:7:0", + "nodeType": "YulIdentifier", + "src": "59395:7:0" + }, + { + "arguments": [ + { + "name": "nu", + "nativeSrc": "59411:2:0", + "nodeType": "YulIdentifier", + "src": "59411:2:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59421:6:0", + "nodeType": "YulLiteral", + "src": "59421:6:0", + "type": "", + "value": "0x0440" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "59415:5:0", + "nodeType": "YulIdentifier", + "src": "59415:5:0" + }, + "nativeSrc": "59415:13:0", + "nodeType": "YulFunctionCall", + "src": "59415:13:0" + }, + { + "name": "r", + "nativeSrc": "59430:1:0", + "nodeType": "YulIdentifier", + "src": "59430:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "59404:6:0", + "nodeType": "YulIdentifier", + "src": "59404:6:0" + }, + "nativeSrc": "59404:28:0", + "nodeType": "YulFunctionCall", + "src": "59404:28:0" + } + ], + "functionName": { + "name": "ec_mul_tmp", + "nativeSrc": "59384:10:0", + "nodeType": "YulIdentifier", + "src": "59384:10:0" + }, + "nativeSrc": "59384:49:0", + "nodeType": "YulFunctionCall", + "src": "59384:49:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "59373:7:0", + "nodeType": "YulIdentifier", + "src": "59373:7:0" + } + ] + }, + { + "nativeSrc": "59454:56:0", + "nodeType": "YulAssignment", + "src": "59454:56:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "59476:7:0", + "nodeType": "YulIdentifier", + "src": "59476:7:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59491:4:0", + "nodeType": "YulLiteral", + "src": "59491:4:0", + "type": "", + "value": "0x80" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "59485:5:0", + "nodeType": "YulIdentifier", + "src": "59485:5:0" + }, + "nativeSrc": "59485:11:0", + "nodeType": "YulFunctionCall", + "src": "59485:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59504:4:0", + "nodeType": "YulLiteral", + "src": "59504:4:0", + "type": "", + "value": "0xa0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "59498:5:0", + "nodeType": "YulIdentifier", + "src": "59498:5:0" + }, + "nativeSrc": "59498:11:0", + "nodeType": "YulFunctionCall", + "src": "59498:11:0" + } + ], + "functionName": { + "name": "ec_add_acc", + "nativeSrc": "59465:10:0", + "nodeType": "YulIdentifier", + "src": "59465:10:0" + }, + "nativeSrc": "59465:45:0", + "nodeType": "YulFunctionCall", + "src": "59465:45:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "59454:7:0", + "nodeType": "YulIdentifier", + "src": "59454:7:0" + } + ] + }, + { + "nativeSrc": "59531:35:0", + "nodeType": "YulAssignment", + "src": "59531:35:0", + "value": { + "arguments": [ + { + "name": "nu", + "nativeSrc": "59544:2:0", + "nodeType": "YulIdentifier", + "src": "59544:2:0" + }, + { + "arguments": [ + { + "name": "NU_MPTR", + "nativeSrc": "59554:7:0", + "nodeType": "YulIdentifier", + "src": "59554:7:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "59548:5:0", + "nodeType": "YulIdentifier", + "src": "59548:5:0" + }, + "nativeSrc": "59548:14:0", + "nodeType": "YulFunctionCall", + "src": "59548:14:0" + }, + { + "name": "r", + "nativeSrc": "59564:1:0", + "nodeType": "YulIdentifier", + "src": "59564:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "59537:6:0", + "nodeType": "YulIdentifier", + "src": "59537:6:0" + }, + "nativeSrc": "59537:29:0", + "nodeType": "YulFunctionCall", + "src": "59537:29:0" + }, + "variableNames": [ + { + "name": "nu", + "nativeSrc": "59531:2:0", + "nodeType": "YulIdentifier", + "src": "59531:2:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59594:4:0", + "nodeType": "YulLiteral", + "src": "59594:4:0", + "type": "", + "value": "0x80" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59613:6:0", + "nodeType": "YulLiteral", + "src": "59613:6:0", + "type": "", + "value": "0x01e4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "59600:12:0", + "nodeType": "YulIdentifier", + "src": "59600:12:0" + }, + "nativeSrc": "59600:20:0", + "nodeType": "YulFunctionCall", + "src": "59600:20:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "59587:6:0", + "nodeType": "YulIdentifier", + "src": "59587:6:0" + }, + "nativeSrc": "59587:34:0", + "nodeType": "YulFunctionCall", + "src": "59587:34:0" + }, + "nativeSrc": "59587:34:0", + "nodeType": "YulExpressionStatement", + "src": "59587:34:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59649:4:0", + "nodeType": "YulLiteral", + "src": "59649:4:0", + "type": "", + "value": "0xa0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59668:6:0", + "nodeType": "YulLiteral", + "src": "59668:6:0", + "type": "", + "value": "0x0204" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "59655:12:0", + "nodeType": "YulIdentifier", + "src": "59655:12:0" + }, + "nativeSrc": "59655:20:0", + "nodeType": "YulFunctionCall", + "src": "59655:20:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "59642:6:0", + "nodeType": "YulIdentifier", + "src": "59642:6:0" + }, + "nativeSrc": "59642:34:0", + "nodeType": "YulFunctionCall", + "src": "59642:34:0" + }, + "nativeSrc": "59642:34:0", + "nodeType": "YulExpressionStatement", + "src": "59642:34:0" + }, + { + "nativeSrc": "59697:60:0", + "nodeType": "YulAssignment", + "src": "59697:60:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "59719:7:0", + "nodeType": "YulIdentifier", + "src": "59719:7:0" + }, + { + "arguments": [ + { + "name": "nu", + "nativeSrc": "59735:2:0", + "nodeType": "YulIdentifier", + "src": "59735:2:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59745:6:0", + "nodeType": "YulLiteral", + "src": "59745:6:0", + "type": "", + "value": "0x0460" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "59739:5:0", + "nodeType": "YulIdentifier", + "src": "59739:5:0" + }, + "nativeSrc": "59739:13:0", + "nodeType": "YulFunctionCall", + "src": "59739:13:0" + }, + { + "name": "r", + "nativeSrc": "59754:1:0", + "nodeType": "YulIdentifier", + "src": "59754:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "59728:6:0", + "nodeType": "YulIdentifier", + "src": "59728:6:0" + }, + "nativeSrc": "59728:28:0", + "nodeType": "YulFunctionCall", + "src": "59728:28:0" + } + ], + "functionName": { + "name": "ec_mul_tmp", + "nativeSrc": "59708:10:0", + "nodeType": "YulIdentifier", + "src": "59708:10:0" + }, + "nativeSrc": "59708:49:0", + "nodeType": "YulFunctionCall", + "src": "59708:49:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "59697:7:0", + "nodeType": "YulIdentifier", + "src": "59697:7:0" + } + ] + }, + { + "nativeSrc": "59778:56:0", + "nodeType": "YulAssignment", + "src": "59778:56:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "59800:7:0", + "nodeType": "YulIdentifier", + "src": "59800:7:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59815:4:0", + "nodeType": "YulLiteral", + "src": "59815:4:0", + "type": "", + "value": "0x80" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "59809:5:0", + "nodeType": "YulIdentifier", + "src": "59809:5:0" + }, + "nativeSrc": "59809:11:0", + "nodeType": "YulFunctionCall", + "src": "59809:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59828:4:0", + "nodeType": "YulLiteral", + "src": "59828:4:0", + "type": "", + "value": "0xa0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "59822:5:0", + "nodeType": "YulIdentifier", + "src": "59822:5:0" + }, + "nativeSrc": "59822:11:0", + "nodeType": "YulFunctionCall", + "src": "59822:11:0" + } + ], + "functionName": { + "name": "ec_add_acc", + "nativeSrc": "59789:10:0", + "nodeType": "YulIdentifier", + "src": "59789:10:0" + }, + "nativeSrc": "59789:45:0", + "nodeType": "YulFunctionCall", + "src": "59789:45:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "59778:7:0", + "nodeType": "YulIdentifier", + "src": "59778:7:0" + } + ] + }, + { + "nativeSrc": "59855:35:0", + "nodeType": "YulAssignment", + "src": "59855:35:0", + "value": { + "arguments": [ + { + "name": "nu", + "nativeSrc": "59868:2:0", + "nodeType": "YulIdentifier", + "src": "59868:2:0" + }, + { + "arguments": [ + { + "name": "NU_MPTR", + "nativeSrc": "59878:7:0", + "nodeType": "YulIdentifier", + "src": "59878:7:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "59872:5:0", + "nodeType": "YulIdentifier", + "src": "59872:5:0" + }, + "nativeSrc": "59872:14:0", + "nodeType": "YulFunctionCall", + "src": "59872:14:0" + }, + { + "name": "r", + "nativeSrc": "59888:1:0", + "nodeType": "YulIdentifier", + "src": "59888:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "59861:6:0", + "nodeType": "YulIdentifier", + "src": "59861:6:0" + }, + "nativeSrc": "59861:29:0", + "nodeType": "YulFunctionCall", + "src": "59861:29:0" + }, + "variableNames": [ + { + "name": "nu", + "nativeSrc": "59855:2:0", + "nodeType": "YulIdentifier", + "src": "59855:2:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59918:4:0", + "nodeType": "YulLiteral", + "src": "59918:4:0", + "type": "", + "value": "0x80" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59937:6:0", + "nodeType": "YulLiteral", + "src": "59937:6:0", + "type": "", + "value": "0x02e4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "59924:12:0", + "nodeType": "YulIdentifier", + "src": "59924:12:0" + }, + "nativeSrc": "59924:20:0", + "nodeType": "YulFunctionCall", + "src": "59924:20:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "59911:6:0", + "nodeType": "YulIdentifier", + "src": "59911:6:0" + }, + "nativeSrc": "59911:34:0", + "nodeType": "YulFunctionCall", + "src": "59911:34:0" + }, + "nativeSrc": "59911:34:0", + "nodeType": "YulExpressionStatement", + "src": "59911:34:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59973:4:0", + "nodeType": "YulLiteral", + "src": "59973:4:0", + "type": "", + "value": "0xa0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "59992:6:0", + "nodeType": "YulLiteral", + "src": "59992:6:0", + "type": "", + "value": "0x0304" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "59979:12:0", + "nodeType": "YulIdentifier", + "src": "59979:12:0" + }, + "nativeSrc": "59979:20:0", + "nodeType": "YulFunctionCall", + "src": "59979:20:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "59966:6:0", + "nodeType": "YulIdentifier", + "src": "59966:6:0" + }, + "nativeSrc": "59966:34:0", + "nodeType": "YulFunctionCall", + "src": "59966:34:0" + }, + "nativeSrc": "59966:34:0", + "nodeType": "YulExpressionStatement", + "src": "59966:34:0" + }, + { + "body": { + "nativeSrc": "60290:202:0", + "nodeType": "YulBlock", + "src": "60290:202:0", + "statements": [ + { + "nativeSrc": "60316:48:0", + "nodeType": "YulAssignment", + "src": "60316:48:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "60338:7:0", + "nodeType": "YulIdentifier", + "src": "60338:7:0" + }, + { + "arguments": [ + { + "name": "ZETA_MPTR", + "nativeSrc": "60353:9:0", + "nodeType": "YulIdentifier", + "src": "60353:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "60347:5:0", + "nodeType": "YulIdentifier", + "src": "60347:5:0" + }, + "nativeSrc": "60347:16:0", + "nodeType": "YulFunctionCall", + "src": "60347:16:0" + } + ], + "functionName": { + "name": "ec_mul_tmp", + "nativeSrc": "60327:10:0", + "nodeType": "YulIdentifier", + "src": "60327:10:0" + }, + "nativeSrc": "60327:37:0", + "nodeType": "YulFunctionCall", + "src": "60327:37:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "60316:7:0", + "nodeType": "YulIdentifier", + "src": "60316:7:0" + } + ] + }, + { + "nativeSrc": "60389:81:0", + "nodeType": "YulAssignment", + "src": "60389:81:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "60411:7:0", + "nodeType": "YulIdentifier", + "src": "60411:7:0" + }, + { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "60433:4:0", + "nodeType": "YulIdentifier", + "src": "60433:4:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "60420:12:0", + "nodeType": "YulIdentifier", + "src": "60420:12:0" + }, + "nativeSrc": "60420:18:0", + "nodeType": "YulFunctionCall", + "src": "60420:18:0" + }, + { + "arguments": [ + { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "60457:4:0", + "nodeType": "YulIdentifier", + "src": "60457:4:0" + }, + { + "kind": "number", + "nativeSrc": "60463:4:0", + "nodeType": "YulLiteral", + "src": "60463:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "add", + "nativeSrc": "60453:3:0", + "nodeType": "YulIdentifier", + "src": "60453:3:0" + }, + "nativeSrc": "60453:15:0", + "nodeType": "YulFunctionCall", + "src": "60453:15:0" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "60440:12:0", + "nodeType": "YulIdentifier", + "src": "60440:12:0" + }, + "nativeSrc": "60440:29:0", + "nodeType": "YulFunctionCall", + "src": "60440:29:0" + } + ], + "functionName": { + "name": "ec_add_tmp", + "nativeSrc": "60400:10:0", + "nodeType": "YulIdentifier", + "src": "60400:10:0" + }, + "nativeSrc": "60400:70:0", + "nodeType": "YulFunctionCall", + "src": "60400:70:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "60389:7:0", + "nodeType": "YulIdentifier", + "src": "60389:7:0" + } + ] + } + ] + }, + "condition": { + "arguments": [ + { + "name": "mptr_end", + "nativeSrc": "60202:8:0", + "nodeType": "YulIdentifier", + "src": "60202:8:0" + }, + { + "name": "mptr", + "nativeSrc": "60212:4:0", + "nodeType": "YulIdentifier", + "src": "60212:4:0" + } + ], + "functionName": { + "name": "lt", + "nativeSrc": "60199:2:0", + "nodeType": "YulIdentifier", + "src": "60199:2:0" + }, + "nativeSrc": "60199:18:0", + "nodeType": "YulFunctionCall", + "src": "60199:18:0" + }, + "nativeSrc": "60021:471:0", + "nodeType": "YulForLoop", + "post": { + "nativeSrc": "60242:27:0", + "nodeType": "YulBlock", + "src": "60242:27:0", + "statements": [ + { + "nativeSrc": "60244:23:0", + "nodeType": "YulAssignment", + "src": "60244:23:0", + "value": { + "arguments": [ + { + "name": "mptr", + "nativeSrc": "60256:4:0", + "nodeType": "YulIdentifier", + "src": "60256:4:0" + }, + { + "kind": "number", + "nativeSrc": "60262:4:0", + "nodeType": "YulLiteral", + "src": "60262:4:0", + "type": "", + "value": "0x40" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "60252:3:0", + "nodeType": "YulIdentifier", + "src": "60252:3:0" + }, + "nativeSrc": "60252:15:0", + "nodeType": "YulFunctionCall", + "src": "60252:15:0" + }, + "variableNames": [ + { + "name": "mptr", + "nativeSrc": "60244:4:0", + "nodeType": "YulIdentifier", + "src": "60244:4:0" + } + ] + } + ] + }, + "pre": { + "nativeSrc": "60049:125:0", + "nodeType": "YulBlock", + "src": "60049:125:0", + "statements": [ + { + "nativeSrc": "60079:18:0", + "nodeType": "YulVariableDeclaration", + "src": "60079:18:0", + "value": { + "kind": "number", + "nativeSrc": "60091:6:0", + "nodeType": "YulLiteral", + "src": "60091:6:0", + "type": "", + "value": "0x02a4" + }, + "variables": [ + { + "name": "mptr", + "nativeSrc": "60083:4:0", + "nodeType": "YulTypedName", + "src": "60083:4:0", + "type": "" + } + ] + }, + { + "nativeSrc": "60126:22:0", + "nodeType": "YulVariableDeclaration", + "src": "60126:22:0", + "value": { + "kind": "number", + "nativeSrc": "60142:6:0", + "nodeType": "YulLiteral", + "src": "60142:6:0", + "type": "", + "value": "0x01e4" + }, + "variables": [ + { + "name": "mptr_end", + "nativeSrc": "60130:8:0", + "nodeType": "YulTypedName", + "src": "60130:8:0", + "type": "" + } + ] + } + ] + }, + "src": "60021:471:0" + }, + { + "nativeSrc": "60513:60:0", + "nodeType": "YulAssignment", + "src": "60513:60:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "60535:7:0", + "nodeType": "YulIdentifier", + "src": "60535:7:0" + }, + { + "arguments": [ + { + "name": "nu", + "nativeSrc": "60551:2:0", + "nodeType": "YulIdentifier", + "src": "60551:2:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "60561:6:0", + "nodeType": "YulLiteral", + "src": "60561:6:0", + "type": "", + "value": "0x0480" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "60555:5:0", + "nodeType": "YulIdentifier", + "src": "60555:5:0" + }, + "nativeSrc": "60555:13:0", + "nodeType": "YulFunctionCall", + "src": "60555:13:0" + }, + { + "name": "r", + "nativeSrc": "60570:1:0", + "nodeType": "YulIdentifier", + "src": "60570:1:0" + } + ], + "functionName": { + "name": "mulmod", + "nativeSrc": "60544:6:0", + "nodeType": "YulIdentifier", + "src": "60544:6:0" + }, + "nativeSrc": "60544:28:0", + "nodeType": "YulFunctionCall", + "src": "60544:28:0" + } + ], + "functionName": { + "name": "ec_mul_tmp", + "nativeSrc": "60524:10:0", + "nodeType": "YulIdentifier", + "src": "60524:10:0" + }, + "nativeSrc": "60524:49:0", + "nodeType": "YulFunctionCall", + "src": "60524:49:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "60513:7:0", + "nodeType": "YulIdentifier", + "src": "60513:7:0" + } + ] + }, + { + "nativeSrc": "60594:56:0", + "nodeType": "YulAssignment", + "src": "60594:56:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "60616:7:0", + "nodeType": "YulIdentifier", + "src": "60616:7:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "60631:4:0", + "nodeType": "YulLiteral", + "src": "60631:4:0", + "type": "", + "value": "0x80" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "60625:5:0", + "nodeType": "YulIdentifier", + "src": "60625:5:0" + }, + "nativeSrc": "60625:11:0", + "nodeType": "YulFunctionCall", + "src": "60625:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "60644:4:0", + "nodeType": "YulLiteral", + "src": "60644:4:0", + "type": "", + "value": "0xa0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "60638:5:0", + "nodeType": "YulIdentifier", + "src": "60638:5:0" + }, + "nativeSrc": "60638:11:0", + "nodeType": "YulFunctionCall", + "src": "60638:11:0" + } + ], + "functionName": { + "name": "ec_add_acc", + "nativeSrc": "60605:10:0", + "nodeType": "YulIdentifier", + "src": "60605:10:0" + }, + "nativeSrc": "60605:45:0", + "nodeType": "YulFunctionCall", + "src": "60605:45:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "60594:7:0", + "nodeType": "YulIdentifier", + "src": "60594:7:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "60678:4:0", + "nodeType": "YulLiteral", + "src": "60678:4:0", + "type": "", + "value": "0x80" + }, + { + "arguments": [ + { + "name": "G1_X_MPTR", + "nativeSrc": "60690:9:0", + "nodeType": "YulIdentifier", + "src": "60690:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "60684:5:0", + "nodeType": "YulIdentifier", + "src": "60684:5:0" + }, + "nativeSrc": "60684:16:0", + "nodeType": "YulFunctionCall", + "src": "60684:16:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "60671:6:0", + "nodeType": "YulIdentifier", + "src": "60671:6:0" + }, + "nativeSrc": "60671:30:0", + "nodeType": "YulFunctionCall", + "src": "60671:30:0" + }, + "nativeSrc": "60671:30:0", + "nodeType": "YulExpressionStatement", + "src": "60671:30:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "60729:4:0", + "nodeType": "YulLiteral", + "src": "60729:4:0", + "type": "", + "value": "0xa0" + }, + { + "arguments": [ + { + "name": "G1_Y_MPTR", + "nativeSrc": "60741:9:0", + "nodeType": "YulIdentifier", + "src": "60741:9:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "60735:5:0", + "nodeType": "YulIdentifier", + "src": "60735:5:0" + }, + "nativeSrc": "60735:16:0", + "nodeType": "YulFunctionCall", + "src": "60735:16:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "60722:6:0", + "nodeType": "YulIdentifier", + "src": "60722:6:0" + }, + "nativeSrc": "60722:30:0", + "nodeType": "YulFunctionCall", + "src": "60722:30:0" + }, + "nativeSrc": "60722:30:0", + "nodeType": "YulExpressionStatement", + "src": "60722:30:0" + }, + { + "nativeSrc": "60773:58:0", + "nodeType": "YulAssignment", + "src": "60773:58:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "60795:7:0", + "nodeType": "YulIdentifier", + "src": "60795:7:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "60808:1:0", + "nodeType": "YulIdentifier", + "src": "60808:1:0" + }, + { + "arguments": [ + { + "name": "R_EVAL_MPTR", + "nativeSrc": "60817:11:0", + "nodeType": "YulIdentifier", + "src": "60817:11:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "60811:5:0", + "nodeType": "YulIdentifier", + "src": "60811:5:0" + }, + "nativeSrc": "60811:18:0", + "nodeType": "YulFunctionCall", + "src": "60811:18:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "60804:3:0", + "nodeType": "YulIdentifier", + "src": "60804:3:0" + }, + "nativeSrc": "60804:26:0", + "nodeType": "YulFunctionCall", + "src": "60804:26:0" + } + ], + "functionName": { + "name": "ec_mul_tmp", + "nativeSrc": "60784:10:0", + "nodeType": "YulIdentifier", + "src": "60784:10:0" + }, + "nativeSrc": "60784:47:0", + "nodeType": "YulFunctionCall", + "src": "60784:47:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "60773:7:0", + "nodeType": "YulIdentifier", + "src": "60773:7:0" + } + ] + }, + { + "nativeSrc": "60852:56:0", + "nodeType": "YulAssignment", + "src": "60852:56:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "60874:7:0", + "nodeType": "YulIdentifier", + "src": "60874:7:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "60889:4:0", + "nodeType": "YulLiteral", + "src": "60889:4:0", + "type": "", + "value": "0x80" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "60883:5:0", + "nodeType": "YulIdentifier", + "src": "60883:5:0" + }, + "nativeSrc": "60883:11:0", + "nodeType": "YulFunctionCall", + "src": "60883:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "60902:4:0", + "nodeType": "YulLiteral", + "src": "60902:4:0", + "type": "", + "value": "0xa0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "60896:5:0", + "nodeType": "YulIdentifier", + "src": "60896:5:0" + }, + "nativeSrc": "60896:11:0", + "nodeType": "YulFunctionCall", + "src": "60896:11:0" + } + ], + "functionName": { + "name": "ec_add_acc", + "nativeSrc": "60863:10:0", + "nodeType": "YulIdentifier", + "src": "60863:10:0" + }, + "nativeSrc": "60863:45:0", + "nodeType": "YulFunctionCall", + "src": "60863:45:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "60852:7:0", + "nodeType": "YulIdentifier", + "src": "60852:7:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "60936:4:0", + "nodeType": "YulLiteral", + "src": "60936:4:0", + "type": "", + "value": "0x80" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "60955:6:0", + "nodeType": "YulLiteral", + "src": "60955:6:0", + "type": "", + "value": "0x08e4" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "60942:12:0", + "nodeType": "YulIdentifier", + "src": "60942:12:0" + }, + "nativeSrc": "60942:20:0", + "nodeType": "YulFunctionCall", + "src": "60942:20:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "60929:6:0", + "nodeType": "YulIdentifier", + "src": "60929:6:0" + }, + "nativeSrc": "60929:34:0", + "nodeType": "YulFunctionCall", + "src": "60929:34:0" + }, + "nativeSrc": "60929:34:0", + "nodeType": "YulExpressionStatement", + "src": "60929:34:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "60991:4:0", + "nodeType": "YulLiteral", + "src": "60991:4:0", + "type": "", + "value": "0xa0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61010:6:0", + "nodeType": "YulLiteral", + "src": "61010:6:0", + "type": "", + "value": "0x0904" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "60997:12:0", + "nodeType": "YulIdentifier", + "src": "60997:12:0" + }, + "nativeSrc": "60997:20:0", + "nodeType": "YulFunctionCall", + "src": "60997:20:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "60984:6:0", + "nodeType": "YulIdentifier", + "src": "60984:6:0" + }, + "nativeSrc": "60984:34:0", + "nodeType": "YulFunctionCall", + "src": "60984:34:0" + }, + "nativeSrc": "60984:34:0", + "nodeType": "YulExpressionStatement", + "src": "60984:34:0" + }, + { + "nativeSrc": "61039:53:0", + "nodeType": "YulAssignment", + "src": "61039:53:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "61061:7:0", + "nodeType": "YulIdentifier", + "src": "61061:7:0" + }, + { + "arguments": [ + { + "name": "r", + "nativeSrc": "61074:1:0", + "nodeType": "YulIdentifier", + "src": "61074:1:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61083:6:0", + "nodeType": "YulLiteral", + "src": "61083:6:0", + "type": "", + "value": "0x0400" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "61077:5:0", + "nodeType": "YulIdentifier", + "src": "61077:5:0" + }, + "nativeSrc": "61077:13:0", + "nodeType": "YulFunctionCall", + "src": "61077:13:0" + } + ], + "functionName": { + "name": "sub", + "nativeSrc": "61070:3:0", + "nodeType": "YulIdentifier", + "src": "61070:3:0" + }, + "nativeSrc": "61070:21:0", + "nodeType": "YulFunctionCall", + "src": "61070:21:0" + } + ], + "functionName": { + "name": "ec_mul_tmp", + "nativeSrc": "61050:10:0", + "nodeType": "YulIdentifier", + "src": "61050:10:0" + }, + "nativeSrc": "61050:42:0", + "nodeType": "YulFunctionCall", + "src": "61050:42:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "61039:7:0", + "nodeType": "YulIdentifier", + "src": "61039:7:0" + } + ] + }, + { + "nativeSrc": "61113:56:0", + "nodeType": "YulAssignment", + "src": "61113:56:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "61135:7:0", + "nodeType": "YulIdentifier", + "src": "61135:7:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61150:4:0", + "nodeType": "YulLiteral", + "src": "61150:4:0", + "type": "", + "value": "0x80" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "61144:5:0", + "nodeType": "YulIdentifier", + "src": "61144:5:0" + }, + "nativeSrc": "61144:11:0", + "nodeType": "YulFunctionCall", + "src": "61144:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61163:4:0", + "nodeType": "YulLiteral", + "src": "61163:4:0", + "type": "", + "value": "0xa0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "61157:5:0", + "nodeType": "YulIdentifier", + "src": "61157:5:0" + }, + "nativeSrc": "61157:11:0", + "nodeType": "YulFunctionCall", + "src": "61157:11:0" + } + ], + "functionName": { + "name": "ec_add_acc", + "nativeSrc": "61124:10:0", + "nodeType": "YulIdentifier", + "src": "61124:10:0" + }, + "nativeSrc": "61124:45:0", + "nodeType": "YulFunctionCall", + "src": "61124:45:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "61113:7:0", + "nodeType": "YulIdentifier", + "src": "61113:7:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61197:4:0", + "nodeType": "YulLiteral", + "src": "61197:4:0", + "type": "", + "value": "0x80" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61216:6:0", + "nodeType": "YulLiteral", + "src": "61216:6:0", + "type": "", + "value": "0x0924" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "61203:12:0", + "nodeType": "YulIdentifier", + "src": "61203:12:0" + }, + "nativeSrc": "61203:20:0", + "nodeType": "YulFunctionCall", + "src": "61203:20:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "61190:6:0", + "nodeType": "YulIdentifier", + "src": "61190:6:0" + }, + "nativeSrc": "61190:34:0", + "nodeType": "YulFunctionCall", + "src": "61190:34:0" + }, + "nativeSrc": "61190:34:0", + "nodeType": "YulExpressionStatement", + "src": "61190:34:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61252:4:0", + "nodeType": "YulLiteral", + "src": "61252:4:0", + "type": "", + "value": "0xa0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61271:6:0", + "nodeType": "YulLiteral", + "src": "61271:6:0", + "type": "", + "value": "0x0944" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "61258:12:0", + "nodeType": "YulIdentifier", + "src": "61258:12:0" + }, + "nativeSrc": "61258:20:0", + "nodeType": "YulFunctionCall", + "src": "61258:20:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "61245:6:0", + "nodeType": "YulIdentifier", + "src": "61245:6:0" + }, + "nativeSrc": "61245:34:0", + "nodeType": "YulFunctionCall", + "src": "61245:34:0" + }, + "nativeSrc": "61245:34:0", + "nodeType": "YulExpressionStatement", + "src": "61245:34:0" + }, + { + "nativeSrc": "61300:46:0", + "nodeType": "YulAssignment", + "src": "61300:46:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "61322:7:0", + "nodeType": "YulIdentifier", + "src": "61322:7:0" + }, + { + "arguments": [ + { + "name": "MU_MPTR", + "nativeSrc": "61337:7:0", + "nodeType": "YulIdentifier", + "src": "61337:7:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "61331:5:0", + "nodeType": "YulIdentifier", + "src": "61331:5:0" + }, + "nativeSrc": "61331:14:0", + "nodeType": "YulFunctionCall", + "src": "61331:14:0" + } + ], + "functionName": { + "name": "ec_mul_tmp", + "nativeSrc": "61311:10:0", + "nodeType": "YulIdentifier", + "src": "61311:10:0" + }, + "nativeSrc": "61311:35:0", + "nodeType": "YulFunctionCall", + "src": "61311:35:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "61300:7:0", + "nodeType": "YulIdentifier", + "src": "61300:7:0" + } + ] + }, + { + "nativeSrc": "61367:56:0", + "nodeType": "YulAssignment", + "src": "61367:56:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "61389:7:0", + "nodeType": "YulIdentifier", + "src": "61389:7:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61404:4:0", + "nodeType": "YulLiteral", + "src": "61404:4:0", + "type": "", + "value": "0x80" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "61398:5:0", + "nodeType": "YulIdentifier", + "src": "61398:5:0" + }, + "nativeSrc": "61398:11:0", + "nodeType": "YulFunctionCall", + "src": "61398:11:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61417:4:0", + "nodeType": "YulLiteral", + "src": "61417:4:0", + "type": "", + "value": "0xa0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "61411:5:0", + "nodeType": "YulIdentifier", + "src": "61411:5:0" + }, + "nativeSrc": "61411:11:0", + "nodeType": "YulFunctionCall", + "src": "61411:11:0" + } + ], + "functionName": { + "name": "ec_add_acc", + "nativeSrc": "61378:10:0", + "nodeType": "YulIdentifier", + "src": "61378:10:0" + }, + "nativeSrc": "61378:45:0", + "nodeType": "YulFunctionCall", + "src": "61378:45:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "61367:7:0", + "nodeType": "YulIdentifier", + "src": "61367:7:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "PAIRING_LHS_X_MPTR", + "nativeSrc": "61451:18:0", + "nodeType": "YulIdentifier", + "src": "61451:18:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61477:4:0", + "nodeType": "YulLiteral", + "src": "61477:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "61471:5:0", + "nodeType": "YulIdentifier", + "src": "61471:5:0" + }, + "nativeSrc": "61471:11:0", + "nodeType": "YulFunctionCall", + "src": "61471:11:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "61444:6:0", + "nodeType": "YulIdentifier", + "src": "61444:6:0" + }, + "nativeSrc": "61444:39:0", + "nodeType": "YulFunctionCall", + "src": "61444:39:0" + }, + "nativeSrc": "61444:39:0", + "nodeType": "YulExpressionStatement", + "src": "61444:39:0" + }, + { + "expression": { + "arguments": [ + { + "name": "PAIRING_LHS_Y_MPTR", + "nativeSrc": "61511:18:0", + "nodeType": "YulIdentifier", + "src": "61511:18:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61537:4:0", + "nodeType": "YulLiteral", + "src": "61537:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "61531:5:0", + "nodeType": "YulIdentifier", + "src": "61531:5:0" + }, + "nativeSrc": "61531:11:0", + "nodeType": "YulFunctionCall", + "src": "61531:11:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "61504:6:0", + "nodeType": "YulIdentifier", + "src": "61504:6:0" + }, + "nativeSrc": "61504:39:0", + "nodeType": "YulFunctionCall", + "src": "61504:39:0" + }, + "nativeSrc": "61504:39:0", + "nodeType": "YulExpressionStatement", + "src": "61504:39:0" + }, + { + "expression": { + "arguments": [ + { + "name": "PAIRING_RHS_X_MPTR", + "nativeSrc": "61571:18:0", + "nodeType": "YulIdentifier", + "src": "61571:18:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61604:6:0", + "nodeType": "YulLiteral", + "src": "61604:6:0", + "type": "", + "value": "0x0924" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "61591:12:0", + "nodeType": "YulIdentifier", + "src": "61591:12:0" + }, + "nativeSrc": "61591:20:0", + "nodeType": "YulFunctionCall", + "src": "61591:20:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "61564:6:0", + "nodeType": "YulIdentifier", + "src": "61564:6:0" + }, + "nativeSrc": "61564:48:0", + "nodeType": "YulFunctionCall", + "src": "61564:48:0" + }, + "nativeSrc": "61564:48:0", + "nodeType": "YulExpressionStatement", + "src": "61564:48:0" + }, + { + "expression": { + "arguments": [ + { + "name": "PAIRING_RHS_Y_MPTR", + "nativeSrc": "61640:18:0", + "nodeType": "YulIdentifier", + "src": "61640:18:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61673:6:0", + "nodeType": "YulLiteral", + "src": "61673:6:0", + "type": "", + "value": "0x0944" + } + ], + "functionName": { + "name": "calldataload", + "nativeSrc": "61660:12:0", + "nodeType": "YulIdentifier", + "src": "61660:12:0" + }, + "nativeSrc": "61660:20:0", + "nodeType": "YulFunctionCall", + "src": "61660:20:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "61633:6:0", + "nodeType": "YulIdentifier", + "src": "61633:6:0" + }, + "nativeSrc": "61633:48:0", + "nodeType": "YulFunctionCall", + "src": "61633:48:0" + }, + "nativeSrc": "61633:48:0", + "nodeType": "YulExpressionStatement", + "src": "61633:48:0" + } + ] + } + ] + }, + { + "body": { + "nativeSrc": "61812:1275:0", + "nodeType": "YulBlock", + "src": "61812:1275:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61837:4:0", + "nodeType": "YulLiteral", + "src": "61837:4:0", + "type": "", + "value": "0x00" + }, + { + "arguments": [ + { + "name": "ACC_LHS_X_MPTR", + "nativeSrc": "61849:14:0", + "nodeType": "YulIdentifier", + "src": "61849:14:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "61843:5:0", + "nodeType": "YulIdentifier", + "src": "61843:5:0" + }, + "nativeSrc": "61843:21:0", + "nodeType": "YulFunctionCall", + "src": "61843:21:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "61830:6:0", + "nodeType": "YulIdentifier", + "src": "61830:6:0" + }, + "nativeSrc": "61830:35:0", + "nodeType": "YulFunctionCall", + "src": "61830:35:0" + }, + "nativeSrc": "61830:35:0", + "nodeType": "YulExpressionStatement", + "src": "61830:35:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61889:4:0", + "nodeType": "YulLiteral", + "src": "61889:4:0", + "type": "", + "value": "0x20" + }, + { + "arguments": [ + { + "name": "ACC_LHS_Y_MPTR", + "nativeSrc": "61901:14:0", + "nodeType": "YulIdentifier", + "src": "61901:14:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "61895:5:0", + "nodeType": "YulIdentifier", + "src": "61895:5:0" + }, + "nativeSrc": "61895:21:0", + "nodeType": "YulFunctionCall", + "src": "61895:21:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "61882:6:0", + "nodeType": "YulIdentifier", + "src": "61882:6:0" + }, + "nativeSrc": "61882:35:0", + "nodeType": "YulFunctionCall", + "src": "61882:35:0" + }, + "nativeSrc": "61882:35:0", + "nodeType": "YulExpressionStatement", + "src": "61882:35:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61941:4:0", + "nodeType": "YulLiteral", + "src": "61941:4:0", + "type": "", + "value": "0x40" + }, + { + "arguments": [ + { + "name": "ACC_RHS_X_MPTR", + "nativeSrc": "61953:14:0", + "nodeType": "YulIdentifier", + "src": "61953:14:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "61947:5:0", + "nodeType": "YulIdentifier", + "src": "61947:5:0" + }, + "nativeSrc": "61947:21:0", + "nodeType": "YulFunctionCall", + "src": "61947:21:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "61934:6:0", + "nodeType": "YulIdentifier", + "src": "61934:6:0" + }, + "nativeSrc": "61934:35:0", + "nodeType": "YulFunctionCall", + "src": "61934:35:0" + }, + "nativeSrc": "61934:35:0", + "nodeType": "YulExpressionStatement", + "src": "61934:35:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "61993:4:0", + "nodeType": "YulLiteral", + "src": "61993:4:0", + "type": "", + "value": "0x60" + }, + { + "arguments": [ + { + "name": "ACC_RHS_Y_MPTR", + "nativeSrc": "62005:14:0", + "nodeType": "YulIdentifier", + "src": "62005:14:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "61999:5:0", + "nodeType": "YulIdentifier", + "src": "61999:5:0" + }, + "nativeSrc": "61999:21:0", + "nodeType": "YulFunctionCall", + "src": "61999:21:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "61986:6:0", + "nodeType": "YulIdentifier", + "src": "61986:6:0" + }, + "nativeSrc": "61986:35:0", + "nodeType": "YulFunctionCall", + "src": "61986:35:0" + }, + "nativeSrc": "61986:35:0", + "nodeType": "YulExpressionStatement", + "src": "61986:35:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "62045:4:0", + "nodeType": "YulLiteral", + "src": "62045:4:0", + "type": "", + "value": "0x80" + }, + { + "arguments": [ + { + "name": "PAIRING_LHS_X_MPTR", + "nativeSrc": "62057:18:0", + "nodeType": "YulIdentifier", + "src": "62057:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "62051:5:0", + "nodeType": "YulIdentifier", + "src": "62051:5:0" + }, + "nativeSrc": "62051:25:0", + "nodeType": "YulFunctionCall", + "src": "62051:25:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "62038:6:0", + "nodeType": "YulIdentifier", + "src": "62038:6:0" + }, + "nativeSrc": "62038:39:0", + "nodeType": "YulFunctionCall", + "src": "62038:39:0" + }, + "nativeSrc": "62038:39:0", + "nodeType": "YulExpressionStatement", + "src": "62038:39:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "62101:4:0", + "nodeType": "YulLiteral", + "src": "62101:4:0", + "type": "", + "value": "0xa0" + }, + { + "arguments": [ + { + "name": "PAIRING_LHS_Y_MPTR", + "nativeSrc": "62113:18:0", + "nodeType": "YulIdentifier", + "src": "62113:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "62107:5:0", + "nodeType": "YulIdentifier", + "src": "62107:5:0" + }, + "nativeSrc": "62107:25:0", + "nodeType": "YulFunctionCall", + "src": "62107:25:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "62094:6:0", + "nodeType": "YulIdentifier", + "src": "62094:6:0" + }, + "nativeSrc": "62094:39:0", + "nodeType": "YulFunctionCall", + "src": "62094:39:0" + }, + "nativeSrc": "62094:39:0", + "nodeType": "YulExpressionStatement", + "src": "62094:39:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "62157:4:0", + "nodeType": "YulLiteral", + "src": "62157:4:0", + "type": "", + "value": "0xc0" + }, + { + "arguments": [ + { + "name": "PAIRING_RHS_X_MPTR", + "nativeSrc": "62169:18:0", + "nodeType": "YulIdentifier", + "src": "62169:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "62163:5:0", + "nodeType": "YulIdentifier", + "src": "62163:5:0" + }, + "nativeSrc": "62163:25:0", + "nodeType": "YulFunctionCall", + "src": "62163:25:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "62150:6:0", + "nodeType": "YulIdentifier", + "src": "62150:6:0" + }, + "nativeSrc": "62150:39:0", + "nodeType": "YulFunctionCall", + "src": "62150:39:0" + }, + "nativeSrc": "62150:39:0", + "nodeType": "YulExpressionStatement", + "src": "62150:39:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "62213:4:0", + "nodeType": "YulLiteral", + "src": "62213:4:0", + "type": "", + "value": "0xe0" + }, + { + "arguments": [ + { + "name": "PAIRING_RHS_Y_MPTR", + "nativeSrc": "62225:18:0", + "nodeType": "YulIdentifier", + "src": "62225:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "62219:5:0", + "nodeType": "YulIdentifier", + "src": "62219:5:0" + }, + "nativeSrc": "62219:25:0", + "nodeType": "YulFunctionCall", + "src": "62219:25:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "62206:6:0", + "nodeType": "YulIdentifier", + "src": "62206:6:0" + }, + "nativeSrc": "62206:39:0", + "nodeType": "YulFunctionCall", + "src": "62206:39:0" + }, + "nativeSrc": "62206:39:0", + "nodeType": "YulExpressionStatement", + "src": "62206:39:0" + }, + { + "nativeSrc": "62262:47:0", + "nodeType": "YulVariableDeclaration", + "src": "62262:47:0", + "value": { + "arguments": [ + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "62293:4:0", + "nodeType": "YulLiteral", + "src": "62293:4:0", + "type": "", + "value": "0x00" + }, + { + "kind": "number", + "nativeSrc": "62299:5:0", + "nodeType": "YulLiteral", + "src": "62299:5:0", + "type": "", + "value": "0x100" + } + ], + "functionName": { + "name": "keccak256", + "nativeSrc": "62283:9:0", + "nodeType": "YulIdentifier", + "src": "62283:9:0" + }, + "nativeSrc": "62283:22:0", + "nodeType": "YulFunctionCall", + "src": "62283:22:0" + }, + { + "name": "r", + "nativeSrc": "62307:1:0", + "nodeType": "YulIdentifier", + "src": "62307:1:0" + } + ], + "functionName": { + "name": "mod", + "nativeSrc": "62279:3:0", + "nodeType": "YulIdentifier", + "src": "62279:3:0" + }, + "nativeSrc": "62279:30:0", + "nodeType": "YulFunctionCall", + "src": "62279:30:0" + }, + "variables": [ + { + "name": "challenge", + "nativeSrc": "62266:9:0", + "nodeType": "YulTypedName", + "src": "62266:9:0", + "type": "" + } + ] + }, + { + "nativeSrc": "62385:41:0", + "nodeType": "YulAssignment", + "src": "62385:41:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "62407:7:0", + "nodeType": "YulIdentifier", + "src": "62407:7:0" + }, + { + "name": "challenge", + "nativeSrc": "62416:9:0", + "nodeType": "YulIdentifier", + "src": "62416:9:0" + } + ], + "functionName": { + "name": "ec_mul_acc", + "nativeSrc": "62396:10:0", + "nodeType": "YulIdentifier", + "src": "62396:10:0" + }, + "nativeSrc": "62396:30:0", + "nodeType": "YulFunctionCall", + "src": "62396:30:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "62385:7:0", + "nodeType": "YulIdentifier", + "src": "62385:7:0" + } + ] + }, + { + "nativeSrc": "62443:84:0", + "nodeType": "YulAssignment", + "src": "62443:84:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "62465:7:0", + "nodeType": "YulIdentifier", + "src": "62465:7:0" + }, + { + "arguments": [ + { + "name": "PAIRING_LHS_X_MPTR", + "nativeSrc": "62480:18:0", + "nodeType": "YulIdentifier", + "src": "62480:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "62474:5:0", + "nodeType": "YulIdentifier", + "src": "62474:5:0" + }, + "nativeSrc": "62474:25:0", + "nodeType": "YulFunctionCall", + "src": "62474:25:0" + }, + { + "arguments": [ + { + "name": "PAIRING_LHS_Y_MPTR", + "nativeSrc": "62507:18:0", + "nodeType": "YulIdentifier", + "src": "62507:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "62501:5:0", + "nodeType": "YulIdentifier", + "src": "62501:5:0" + }, + "nativeSrc": "62501:25:0", + "nodeType": "YulFunctionCall", + "src": "62501:25:0" + } + ], + "functionName": { + "name": "ec_add_acc", + "nativeSrc": "62454:10:0", + "nodeType": "YulIdentifier", + "src": "62454:10:0" + }, + "nativeSrc": "62454:73:0", + "nodeType": "YulFunctionCall", + "src": "62454:73:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "62443:7:0", + "nodeType": "YulIdentifier", + "src": "62443:7:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "PAIRING_LHS_X_MPTR", + "nativeSrc": "62551:18:0", + "nodeType": "YulIdentifier", + "src": "62551:18:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "62577:4:0", + "nodeType": "YulLiteral", + "src": "62577:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "62571:5:0", + "nodeType": "YulIdentifier", + "src": "62571:5:0" + }, + "nativeSrc": "62571:11:0", + "nodeType": "YulFunctionCall", + "src": "62571:11:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "62544:6:0", + "nodeType": "YulIdentifier", + "src": "62544:6:0" + }, + "nativeSrc": "62544:39:0", + "nodeType": "YulFunctionCall", + "src": "62544:39:0" + }, + "nativeSrc": "62544:39:0", + "nodeType": "YulExpressionStatement", + "src": "62544:39:0" + }, + { + "expression": { + "arguments": [ + { + "name": "PAIRING_LHS_Y_MPTR", + "nativeSrc": "62607:18:0", + "nodeType": "YulIdentifier", + "src": "62607:18:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "62633:4:0", + "nodeType": "YulLiteral", + "src": "62633:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "62627:5:0", + "nodeType": "YulIdentifier", + "src": "62627:5:0" + }, + "nativeSrc": "62627:11:0", + "nodeType": "YulFunctionCall", + "src": "62627:11:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "62600:6:0", + "nodeType": "YulIdentifier", + "src": "62600:6:0" + }, + "nativeSrc": "62600:39:0", + "nodeType": "YulFunctionCall", + "src": "62600:39:0" + }, + "nativeSrc": "62600:39:0", + "nodeType": "YulExpressionStatement", + "src": "62600:39:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "62722:4:0", + "nodeType": "YulLiteral", + "src": "62722:4:0", + "type": "", + "value": "0x00" + }, + { + "arguments": [ + { + "name": "ACC_RHS_X_MPTR", + "nativeSrc": "62734:14:0", + "nodeType": "YulIdentifier", + "src": "62734:14:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "62728:5:0", + "nodeType": "YulIdentifier", + "src": "62728:5:0" + }, + "nativeSrc": "62728:21:0", + "nodeType": "YulFunctionCall", + "src": "62728:21:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "62715:6:0", + "nodeType": "YulIdentifier", + "src": "62715:6:0" + }, + "nativeSrc": "62715:35:0", + "nodeType": "YulFunctionCall", + "src": "62715:35:0" + }, + "nativeSrc": "62715:35:0", + "nodeType": "YulExpressionStatement", + "src": "62715:35:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "62774:4:0", + "nodeType": "YulLiteral", + "src": "62774:4:0", + "type": "", + "value": "0x20" + }, + { + "arguments": [ + { + "name": "ACC_RHS_Y_MPTR", + "nativeSrc": "62786:14:0", + "nodeType": "YulIdentifier", + "src": "62786:14:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "62780:5:0", + "nodeType": "YulIdentifier", + "src": "62780:5:0" + }, + "nativeSrc": "62780:21:0", + "nodeType": "YulFunctionCall", + "src": "62780:21:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "62767:6:0", + "nodeType": "YulIdentifier", + "src": "62767:6:0" + }, + "nativeSrc": "62767:35:0", + "nodeType": "YulFunctionCall", + "src": "62767:35:0" + }, + "nativeSrc": "62767:35:0", + "nodeType": "YulExpressionStatement", + "src": "62767:35:0" + }, + { + "nativeSrc": "62819:41:0", + "nodeType": "YulAssignment", + "src": "62819:41:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "62841:7:0", + "nodeType": "YulIdentifier", + "src": "62841:7:0" + }, + { + "name": "challenge", + "nativeSrc": "62850:9:0", + "nodeType": "YulIdentifier", + "src": "62850:9:0" + } + ], + "functionName": { + "name": "ec_mul_acc", + "nativeSrc": "62830:10:0", + "nodeType": "YulIdentifier", + "src": "62830:10:0" + }, + "nativeSrc": "62830:30:0", + "nodeType": "YulFunctionCall", + "src": "62830:30:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "62819:7:0", + "nodeType": "YulIdentifier", + "src": "62819:7:0" + } + ] + }, + { + "nativeSrc": "62877:84:0", + "nodeType": "YulAssignment", + "src": "62877:84:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "62899:7:0", + "nodeType": "YulIdentifier", + "src": "62899:7:0" + }, + { + "arguments": [ + { + "name": "PAIRING_RHS_X_MPTR", + "nativeSrc": "62914:18:0", + "nodeType": "YulIdentifier", + "src": "62914:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "62908:5:0", + "nodeType": "YulIdentifier", + "src": "62908:5:0" + }, + "nativeSrc": "62908:25:0", + "nodeType": "YulFunctionCall", + "src": "62908:25:0" + }, + { + "arguments": [ + { + "name": "PAIRING_RHS_Y_MPTR", + "nativeSrc": "62941:18:0", + "nodeType": "YulIdentifier", + "src": "62941:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "62935:5:0", + "nodeType": "YulIdentifier", + "src": "62935:5:0" + }, + "nativeSrc": "62935:25:0", + "nodeType": "YulFunctionCall", + "src": "62935:25:0" + } + ], + "functionName": { + "name": "ec_add_acc", + "nativeSrc": "62888:10:0", + "nodeType": "YulIdentifier", + "src": "62888:10:0" + }, + "nativeSrc": "62888:73:0", + "nodeType": "YulFunctionCall", + "src": "62888:73:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "62877:7:0", + "nodeType": "YulIdentifier", + "src": "62877:7:0" + } + ] + }, + { + "expression": { + "arguments": [ + { + "name": "PAIRING_RHS_X_MPTR", + "nativeSrc": "62985:18:0", + "nodeType": "YulIdentifier", + "src": "62985:18:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "63011:4:0", + "nodeType": "YulLiteral", + "src": "63011:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "63005:5:0", + "nodeType": "YulIdentifier", + "src": "63005:5:0" + }, + "nativeSrc": "63005:11:0", + "nodeType": "YulFunctionCall", + "src": "63005:11:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "62978:6:0", + "nodeType": "YulIdentifier", + "src": "62978:6:0" + }, + "nativeSrc": "62978:39:0", + "nodeType": "YulFunctionCall", + "src": "62978:39:0" + }, + "nativeSrc": "62978:39:0", + "nodeType": "YulExpressionStatement", + "src": "62978:39:0" + }, + { + "expression": { + "arguments": [ + { + "name": "PAIRING_RHS_Y_MPTR", + "nativeSrc": "63041:18:0", + "nodeType": "YulIdentifier", + "src": "63041:18:0" + }, + { + "arguments": [ + { + "kind": "number", + "nativeSrc": "63067:4:0", + "nodeType": "YulLiteral", + "src": "63067:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "63061:5:0", + "nodeType": "YulIdentifier", + "src": "63061:5:0" + }, + "nativeSrc": "63061:11:0", + "nodeType": "YulFunctionCall", + "src": "63061:11:0" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "63034:6:0", + "nodeType": "YulIdentifier", + "src": "63034:6:0" + }, + "nativeSrc": "63034:39:0", + "nodeType": "YulFunctionCall", + "src": "63034:39:0" + }, + "nativeSrc": "63034:39:0", + "nodeType": "YulExpressionStatement", + "src": "63034:39:0" + } + ] + }, + "condition": { + "arguments": [ + { + "name": "HAS_ACCUMULATOR_MPTR", + "nativeSrc": "61790:20:0", + "nodeType": "YulIdentifier", + "src": "61790:20:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "61784:5:0", + "nodeType": "YulIdentifier", + "src": "61784:5:0" + }, + "nativeSrc": "61784:27:0", + "nodeType": "YulFunctionCall", + "src": "61784:27:0" + }, + "nativeSrc": "61781:1306:0", + "nodeType": "YulIf", + "src": "61781:1306:0" + }, + { + "nativeSrc": "63132:232:0", + "nodeType": "YulAssignment", + "src": "63132:232:0", + "value": { + "arguments": [ + { + "name": "success", + "nativeSrc": "63171:7:0", + "nodeType": "YulIdentifier", + "src": "63171:7:0" + }, + { + "arguments": [ + { + "name": "PAIRING_LHS_X_MPTR", + "nativeSrc": "63202:18:0", + "nodeType": "YulIdentifier", + "src": "63202:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "63196:5:0", + "nodeType": "YulIdentifier", + "src": "63196:5:0" + }, + "nativeSrc": "63196:25:0", + "nodeType": "YulFunctionCall", + "src": "63196:25:0" + }, + { + "arguments": [ + { + "name": "PAIRING_LHS_Y_MPTR", + "nativeSrc": "63245:18:0", + "nodeType": "YulIdentifier", + "src": "63245:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "63239:5:0", + "nodeType": "YulIdentifier", + "src": "63239:5:0" + }, + "nativeSrc": "63239:25:0", + "nodeType": "YulFunctionCall", + "src": "63239:25:0" + }, + { + "arguments": [ + { + "name": "PAIRING_RHS_X_MPTR", + "nativeSrc": "63288:18:0", + "nodeType": "YulIdentifier", + "src": "63288:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "63282:5:0", + "nodeType": "YulIdentifier", + "src": "63282:5:0" + }, + "nativeSrc": "63282:25:0", + "nodeType": "YulFunctionCall", + "src": "63282:25:0" + }, + { + "arguments": [ + { + "name": "PAIRING_RHS_Y_MPTR", + "nativeSrc": "63331:18:0", + "nodeType": "YulIdentifier", + "src": "63331:18:0" + } + ], + "functionName": { + "name": "mload", + "nativeSrc": "63325:5:0", + "nodeType": "YulIdentifier", + "src": "63325:5:0" + }, + "nativeSrc": "63325:25:0", + "nodeType": "YulFunctionCall", + "src": "63325:25:0" + } + ], + "functionName": { + "name": "ec_pairing", + "nativeSrc": "63143:10:0", + "nodeType": "YulIdentifier", + "src": "63143:10:0" + }, + "nativeSrc": "63143:221:0", + "nodeType": "YulFunctionCall", + "src": "63143:221:0" + }, + "variableNames": [ + { + "name": "success", + "nativeSrc": "63132:7:0", + "nodeType": "YulIdentifier", + "src": "63132:7:0" + } + ] + }, + { + "body": { + "nativeSrc": "63437:50:0", + "nodeType": "YulBlock", + "src": "63437:50:0", + "statements": [ + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "63462:4:0", + "nodeType": "YulLiteral", + "src": "63462:4:0", + "type": "", + "value": "0x00" + }, + { + "kind": "number", + "nativeSrc": "63468:4:0", + "nodeType": "YulLiteral", + "src": "63468:4:0", + "type": "", + "value": "0x00" + } + ], + "functionName": { + "name": "revert", + "nativeSrc": "63455:6:0", + "nodeType": "YulIdentifier", + "src": "63455:6:0" + }, + "nativeSrc": "63455:18:0", + "nodeType": "YulFunctionCall", + "src": "63455:18:0" + }, + "nativeSrc": "63455:18:0", + "nodeType": "YulExpressionStatement", + "src": "63455:18:0" + } + ] + }, + "condition": { + "arguments": [ + { + "name": "success", + "nativeSrc": "63428:7:0", + "nodeType": "YulIdentifier", + "src": "63428:7:0" + } + ], + "functionName": { + "name": "iszero", + "nativeSrc": "63421:6:0", + "nodeType": "YulIdentifier", + "src": "63421:6:0" + }, + "nativeSrc": "63421:15:0", + "nodeType": "YulFunctionCall", + "src": "63421:15:0" + }, + "nativeSrc": "63418:69:0", + "nodeType": "YulIf", + "src": "63418:69:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "63565:4:0", + "nodeType": "YulLiteral", + "src": "63565:4:0", + "type": "", + "value": "0x00" + }, + { + "kind": "number", + "nativeSrc": "63571:1:0", + "nodeType": "YulLiteral", + "src": "63571:1:0", + "type": "", + "value": "1" + } + ], + "functionName": { + "name": "mstore", + "nativeSrc": "63558:6:0", + "nodeType": "YulIdentifier", + "src": "63558:6:0" + }, + "nativeSrc": "63558:15:0", + "nodeType": "YulFunctionCall", + "src": "63558:15:0" + }, + "nativeSrc": "63558:15:0", + "nodeType": "YulExpressionStatement", + "src": "63558:15:0" + }, + { + "expression": { + "arguments": [ + { + "kind": "number", + "nativeSrc": "63593:4:0", + "nodeType": "YulLiteral", + "src": "63593:4:0", + "type": "", + "value": "0x00" + }, + { + "kind": "number", + "nativeSrc": "63599:4:0", + "nodeType": "YulLiteral", + "src": "63599:4:0", + "type": "", + "value": "0x20" + } + ], + "functionName": { + "name": "return", + "nativeSrc": "63586:6:0", + "nodeType": "YulIdentifier", + "src": "63586:6:0" + }, + "nativeSrc": "63586:18:0", + "nodeType": "YulFunctionCall", + "src": "63586:18:0" + }, + "nativeSrc": "63586:18:0", + "nodeType": "YulExpressionStatement", + "src": "63586:18:0" + } + ] + }, + "evmVersion": "paris", + "externalReferences": [ + { + "declaration": 115, + "isOffset": false, + "isSlot": false, + "src": "22391:14:0", + "valueSize": 1 + }, + { + "declaration": 115, + "isOffset": false, + "isSlot": false, + "src": "61849:14:0", + "valueSize": 1 + }, + { + "declaration": 118, + "isOffset": false, + "isSlot": false, + "src": "22441:14:0", + "valueSize": 1 + }, + { + "declaration": 118, + "isOffset": false, + "isSlot": false, + "src": "61901:14:0", + "valueSize": 1 + }, + { + "declaration": 49, + "isOffset": false, + "isSlot": false, + "src": "20873:15:0", + "valueSize": 1 + }, + { + "declaration": 121, + "isOffset": false, + "isSlot": false, + "src": "22491:14:0", + "valueSize": 1 + }, + { + "declaration": 121, + "isOffset": false, + "isSlot": false, + "src": "61953:14:0", + "valueSize": 1 + }, + { + "declaration": 121, + "isOffset": false, + "isSlot": false, + "src": "62734:14:0", + "valueSize": 1 + }, + { + "declaration": 124, + "isOffset": false, + "isSlot": false, + "src": "22541:14:0", + "valueSize": 1 + }, + { + "declaration": 124, + "isOffset": false, + "isSlot": false, + "src": "62005:14:0", + "valueSize": 1 + }, + { + "declaration": 124, + "isOffset": false, + "isSlot": false, + "src": "62786:14:0", + "valueSize": 1 + }, + { + "declaration": 94, + "isOffset": false, + "isSlot": false, + "src": "35213:9:0", + "valueSize": 1 + }, + { + "declaration": 94, + "isOffset": false, + "isSlot": false, + "src": "36733:9:0", + "valueSize": 1 + }, + { + "declaration": 94, + "isOffset": false, + "isSlot": false, + "src": "38333:9:0", + "valueSize": 1 + }, + { + "declaration": 94, + "isOffset": false, + "isSlot": false, + "src": "40809:9:0", + "valueSize": 1 + }, + { + "declaration": 94, + "isOffset": false, + "isSlot": false, + "src": "43285:9:0", + "valueSize": 1 + }, + { + "declaration": 88, + "isOffset": false, + "isSlot": false, + "src": "17686:14:0", + "valueSize": 1 + }, + { + "declaration": 16, + "isOffset": false, + "isSlot": false, + "src": "45827:21:0", + "valueSize": 1 + }, + { + "declaration": 58, + "isOffset": false, + "isSlot": false, + "src": "60690:9:0", + "valueSize": 1 + }, + { + "declaration": 61, + "isOffset": false, + "isSlot": false, + "src": "60741:9:0", + "valueSize": 1 + }, + { + "declaration": 64, + "isOffset": false, + "isSlot": false, + "src": "9026:11:0", + "valueSize": 1 + }, + { + "declaration": 67, + "isOffset": false, + "isSlot": false, + "src": "9075:11:0", + "valueSize": 1 + }, + { + "declaration": 70, + "isOffset": false, + "isSlot": false, + "src": "9124:11:0", + "valueSize": 1 + }, + { + "declaration": 73, + "isOffset": false, + "isSlot": false, + "src": "9173:11:0", + "valueSize": 1 + }, + { + "declaration": 97, + "isOffset": false, + "isSlot": false, + "src": "35163:10:0", + "valueSize": 1 + }, + { + "declaration": 97, + "isOffset": false, + "isSlot": false, + "src": "36683:10:0", + "valueSize": 1 + }, + { + "declaration": 46, + "isOffset": false, + "isSlot": false, + "src": "20653:20:0", + "valueSize": 1 + }, + { + "declaration": 46, + "isOffset": false, + "isSlot": false, + "src": "61790:20:0", + "valueSize": 1 + }, + { + "declaration": 13, + "isOffset": false, + "isSlot": false, + "src": "17069:13:0", + "valueSize": 1 + }, + { + "declaration": 13, + "isOffset": false, + "isSlot": false, + "src": "20848:13:0", + "valueSize": 1 + }, + { + "declaration": 13, + "isOffset": false, + "isSlot": false, + "src": "24843:13:0", + "valueSize": 1 + }, + { + "declaration": 13, + "isOffset": false, + "isSlot": false, + "src": "24903:13:0", + "valueSize": 1 + }, + { + "declaration": 13, + "isOffset": false, + "isSlot": false, + "src": "25043:13:0", + "valueSize": 1 + }, + { + "declaration": 142, + "isOffset": false, + "isSlot": false, + "src": "25884:18:0", + "valueSize": 1 + }, + { + "declaration": 142, + "isOffset": false, + "isSlot": false, + "src": "37039:18:0", + "valueSize": 1 + }, + { + "declaration": 142, + "isOffset": false, + "isSlot": false, + "src": "37346:18:0", + "valueSize": 1 + }, + { + "declaration": 28, + "isOffset": false, + "isSlot": false, + "src": "22878:6:0", + "valueSize": 1 + }, + { + "declaration": 19, + "isOffset": false, + "isSlot": false, + "src": "45531:20:0", + "valueSize": 1 + }, + { + "declaration": 19, + "isOffset": false, + "isSlot": false, + "src": "45600:20:0", + "valueSize": 1 + }, + { + "declaration": 19, + "isOffset": false, + "isSlot": false, + "src": "45755:20:0", + "valueSize": 1 + }, + { + "declaration": 139, + "isOffset": false, + "isSlot": false, + "src": "25846:8:0", + "valueSize": 1 + }, + { + "declaration": 139, + "isOffset": false, + "isSlot": false, + "src": "34318:8:0", + "valueSize": 1 + }, + { + "declaration": 139, + "isOffset": false, + "isSlot": false, + "src": "34917:8:0", + "valueSize": 1 + }, + { + "declaration": 139, + "isOffset": false, + "isSlot": false, + "src": "37780:8:0", + "valueSize": 1 + }, + { + "declaration": 139, + "isOffset": false, + "isSlot": false, + "src": "40256:8:0", + "valueSize": 1 + }, + { + "declaration": 139, + "isOffset": false, + "isSlot": false, + "src": "42732:8:0", + "valueSize": 1 + }, + { + "declaration": 136, + "isOffset": false, + "isSlot": false, + "src": "25800:12:0", + "valueSize": 1 + }, + { + "declaration": 136, + "isOffset": false, + "isSlot": false, + "src": "36487:12:0", + "valueSize": 1 + }, + { + "declaration": 136, + "isOffset": false, + "isSlot": false, + "src": "37586:12:0", + "valueSize": 1 + }, + { + "declaration": 136, + "isOffset": false, + "isSlot": false, + "src": "40013:12:0", + "valueSize": 1 + }, + { + "declaration": 136, + "isOffset": false, + "isSlot": false, + "src": "42489:12:0", + "valueSize": 1 + }, + { + "declaration": 136, + "isOffset": false, + "isSlot": false, + "src": "45022:12:0", + "valueSize": 1 + }, + { + "declaration": 133, + "isOffset": false, + "isSlot": false, + "src": "25756:11:0", + "valueSize": 1 + }, + { + "declaration": 133, + "isOffset": false, + "isSlot": false, + "src": "34656:11:0", + "valueSize": 1 + }, + { + "declaration": 133, + "isOffset": false, + "isSlot": false, + "src": "36467:11:0", + "valueSize": 1 + }, + { + "declaration": 133, + "isOffset": false, + "isSlot": false, + "src": "37566:11:0", + "valueSize": 1 + }, + { + "declaration": 133, + "isOffset": false, + "isSlot": false, + "src": "38029:11:0", + "valueSize": 1 + }, + { + "declaration": 133, + "isOffset": false, + "isSlot": false, + "src": "40034:11:0", + "valueSize": 1 + }, + { + "declaration": 133, + "isOffset": false, + "isSlot": false, + "src": "40505:11:0", + "valueSize": 1 + }, + { + "declaration": 133, + "isOffset": false, + "isSlot": false, + "src": "42510:11:0", + "valueSize": 1 + }, + { + "declaration": 133, + "isOffset": false, + "isSlot": false, + "src": "42981:11:0", + "valueSize": 1 + }, + { + "declaration": 133, + "isOffset": false, + "isSlot": false, + "src": "45043:11:0", + "valueSize": 1 + }, + { + "declaration": 112, + "isOffset": false, + "isSlot": false, + "src": "47289:7:0", + "valueSize": 1 + }, + { + "declaration": 112, + "isOffset": false, + "isSlot": false, + "src": "61337:7:0", + "valueSize": 1 + }, + { + "declaration": 76, + "isOffset": false, + "isSlot": false, + "src": "9295:17:0", + "valueSize": 1 + }, + { + "declaration": 79, + "isOffset": false, + "isSlot": false, + "src": "9351:17:0", + "valueSize": 1 + }, + { + "declaration": 82, + "isOffset": false, + "isSlot": false, + "src": "9407:17:0", + "valueSize": 1 + }, + { + "declaration": 85, + "isOffset": false, + "isSlot": false, + "src": "9463:17:0", + "valueSize": 1 + }, + { + "declaration": 52, + "isOffset": false, + "isSlot": false, + "src": "20720:18:0", + "valueSize": 1 + }, + { + "declaration": 55, + "isOffset": false, + "isSlot": false, + "src": "20787:22:0", + "valueSize": 1 + }, + { + "declaration": 43, + "isOffset": false, + "isSlot": false, + "src": "16710:18:0", + "valueSize": 1 + }, + { + "declaration": 43, + "isOffset": false, + "isSlot": false, + "src": "23316:18:0", + "valueSize": 1 + }, + { + "declaration": 43, + "isOffset": false, + "isSlot": false, + "src": "25074:18:0", + "valueSize": 1 + }, + { + "declaration": 10, + "isOffset": false, + "isSlot": false, + "src": "16801:17:0", + "valueSize": 1 + }, + { + "declaration": 109, + "isOffset": false, + "isSlot": false, + "src": "57411:7:0", + "valueSize": 1 + }, + { + "declaration": 109, + "isOffset": false, + "isSlot": false, + "src": "57670:7:0", + "valueSize": 1 + }, + { + "declaration": 109, + "isOffset": false, + "isSlot": false, + "src": "59554:7:0", + "valueSize": 1 + }, + { + "declaration": 109, + "isOffset": false, + "isSlot": false, + "src": "59878:7:0", + "valueSize": 1 + }, + { + "declaration": 31, + "isOffset": false, + "isSlot": false, + "src": "23976:10:0", + "valueSize": 1 + }, + { + "declaration": 37, + "isOffset": false, + "isSlot": false, + "src": "46511:14:0", + "valueSize": 1 + }, + { + "declaration": 40, + "isOffset": false, + "isSlot": false, + "src": "23410:19:0", + "valueSize": 1 + }, + { + "declaration": 40, + "isOffset": false, + "isSlot": false, + "src": "24060:19:0", + "valueSize": 1 + }, + { + "declaration": 34, + "isOffset": false, + "isSlot": false, + "src": "23204:10:0", + "valueSize": 1 + }, + { + "declaration": 34, + "isOffset": false, + "isSlot": false, + "src": "46456:10:0", + "valueSize": 1 + }, + { + "declaration": 157, + "isOffset": false, + "isSlot": false, + "src": "61451:18:0", + "valueSize": 1 + }, + { + "declaration": 157, + "isOffset": false, + "isSlot": false, + "src": "62057:18:0", + "valueSize": 1 + }, + { + "declaration": 157, + "isOffset": false, + "isSlot": false, + "src": "62480:18:0", + "valueSize": 1 + }, + { + "declaration": 157, + "isOffset": false, + "isSlot": false, + "src": "62551:18:0", + "valueSize": 1 + }, + { + "declaration": 157, + "isOffset": false, + "isSlot": false, + "src": "63202:18:0", + "valueSize": 1 + }, + { + "declaration": 160, + "isOffset": false, + "isSlot": false, + "src": "61511:18:0", + "valueSize": 1 + }, + { + "declaration": 160, + "isOffset": false, + "isSlot": false, + "src": "62113:18:0", + "valueSize": 1 + }, + { + "declaration": 160, + "isOffset": false, + "isSlot": false, + "src": "62507:18:0", + "valueSize": 1 + }, + { + "declaration": 160, + "isOffset": false, + "isSlot": false, + "src": "62607:18:0", + "valueSize": 1 + }, + { + "declaration": 160, + "isOffset": false, + "isSlot": false, + "src": "63245:18:0", + "valueSize": 1 + }, + { + "declaration": 163, + "isOffset": false, + "isSlot": false, + "src": "61571:18:0", + "valueSize": 1 + }, + { + "declaration": 163, + "isOffset": false, + "isSlot": false, + "src": "62169:18:0", + "valueSize": 1 + }, + { + "declaration": 163, + "isOffset": false, + "isSlot": false, + "src": "62914:18:0", + "valueSize": 1 + }, + { + "declaration": 163, + "isOffset": false, + "isSlot": false, + "src": "62985:18:0", + "valueSize": 1 + }, + { + "declaration": 163, + "isOffset": false, + "isSlot": false, + "src": "63288:18:0", + "valueSize": 1 + }, + { + "declaration": 166, + "isOffset": false, + "isSlot": false, + "src": "61640:18:0", + "valueSize": 1 + }, + { + "declaration": 166, + "isOffset": false, + "isSlot": false, + "src": "62225:18:0", + "valueSize": 1 + }, + { + "declaration": 166, + "isOffset": false, + "isSlot": false, + "src": "62941:18:0", + "valueSize": 1 + }, + { + "declaration": 166, + "isOffset": false, + "isSlot": false, + "src": "63041:18:0", + "valueSize": 1 + }, + { + "declaration": 166, + "isOffset": false, + "isSlot": false, + "src": "63331:18:0", + "valueSize": 1 + }, + { + "declaration": 7, + "isOffset": false, + "isSlot": false, + "src": "17637:10:0", + "valueSize": 1 + }, + { + "declaration": 4, + "isOffset": false, + "isSlot": false, + "src": "16597:14:0", + "valueSize": 1 + }, + { + "declaration": 145, + "isOffset": false, + "isSlot": false, + "src": "45382:18:0", + "valueSize": 1 + }, + { + "declaration": 145, + "isOffset": false, + "isSlot": false, + "src": "51758:18:0", + "valueSize": 1 + }, + { + "declaration": 148, + "isOffset": false, + "isSlot": false, + "src": "46201:15:0", + "valueSize": 1 + }, + { + "declaration": 148, + "isOffset": false, + "isSlot": false, + "src": "57915:15:0", + "valueSize": 1 + }, + { + "declaration": 151, + "isOffset": false, + "isSlot": false, + "src": "46254:15:0", + "valueSize": 1 + }, + { + "declaration": 151, + "isOffset": false, + "isSlot": false, + "src": "57939:15:0", + "valueSize": 1 + }, + { + "declaration": 154, + "isOffset": false, + "isSlot": false, + "src": "57577:11:0", + "valueSize": 1 + }, + { + "declaration": 154, + "isOffset": false, + "isSlot": false, + "src": "60817:11:0", + "valueSize": 1 + }, + { + "declaration": 91, + "isOffset": false, + "isSlot": false, + "src": "38283:10:0", + "valueSize": 1 + }, + { + "declaration": 91, + "isOffset": false, + "isSlot": false, + "src": "40759:10:0", + "valueSize": 1 + }, + { + "declaration": 91, + "isOffset": false, + "isSlot": false, + "src": "43235:10:0", + "valueSize": 1 + }, + { + "declaration": 25, + "isOffset": false, + "isSlot": false, + "src": "16894:14:0", + "valueSize": 1 + }, + { + "declaration": 103, + "isOffset": false, + "isSlot": false, + "src": "22917:6:0", + "valueSize": 1 + }, + { + "declaration": 103, + "isOffset": false, + "isSlot": false, + "src": "35776:6:0", + "valueSize": 1 + }, + { + "declaration": 103, + "isOffset": false, + "isSlot": false, + "src": "46409:6:0", + "valueSize": 1 + }, + { + "declaration": 130, + "isOffset": false, + "isSlot": false, + "src": "25694:20:0", + "valueSize": 1 + }, + { + "declaration": 130, + "isOffset": false, + "isSlot": false, + "src": "45333:20:0", + "valueSize": 1 + }, + { + "declaration": 127, + "isOffset": false, + "isSlot": false, + "src": "23245:8:0", + "valueSize": 1 + }, + { + "declaration": 127, + "isOffset": false, + "isSlot": false, + "src": "23848:8:0", + "valueSize": 1 + }, + { + "declaration": 127, + "isOffset": false, + "isSlot": false, + "src": "23907:8:0", + "valueSize": 1 + }, + { + "declaration": 127, + "isOffset": false, + "isSlot": false, + "src": "24409:8:0", + "valueSize": 1 + }, + { + "declaration": 127, + "isOffset": false, + "isSlot": false, + "src": "24462:8:0", + "valueSize": 1 + }, + { + "declaration": 127, + "isOffset": false, + "isSlot": false, + "src": "24544:8:0", + "valueSize": 1 + }, + { + "declaration": 127, + "isOffset": false, + "isSlot": false, + "src": "25568:8:0", + "valueSize": 1 + }, + { + "declaration": 127, + "isOffset": false, + "isSlot": false, + "src": "25615:8:0", + "valueSize": 1 + }, + { + "declaration": 127, + "isOffset": false, + "isSlot": false, + "src": "25656:8:0", + "valueSize": 1 + }, + { + "declaration": 127, + "isOffset": false, + "isSlot": false, + "src": "45663:8:0", + "valueSize": 1 + }, + { + "declaration": 100, + "isOffset": false, + "isSlot": false, + "src": "26169:6:0", + "valueSize": 1 + }, + { + "declaration": 106, + "isOffset": false, + "isSlot": false, + "src": "51504:9:0", + "valueSize": 1 + }, + { + "declaration": 106, + "isOffset": false, + "isSlot": false, + "src": "53453:9:0", + "valueSize": 1 + }, + { + "declaration": 106, + "isOffset": false, + "isSlot": false, + "src": "53868:9:0", + "valueSize": 1 + }, + { + "declaration": 106, + "isOffset": false, + "isSlot": false, + "src": "54377:9:0", + "valueSize": 1 + }, + { + "declaration": 106, + "isOffset": false, + "isSlot": false, + "src": "57846:9:0", + "valueSize": 1 + }, + { + "declaration": 106, + "isOffset": false, + "isSlot": false, + "src": "58309:9:0", + "valueSize": 1 + }, + { + "declaration": 106, + "isOffset": false, + "isSlot": false, + "src": "58785:9:0", + "valueSize": 1 + }, + { + "declaration": 106, + "isOffset": false, + "isSlot": false, + "src": "58982:9:0", + "valueSize": 1 + }, + { + "declaration": 106, + "isOffset": false, + "isSlot": false, + "src": "59142:9:0", + "valueSize": 1 + }, + { + "declaration": 106, + "isOffset": false, + "isSlot": false, + "src": "60353:9:0", + "valueSize": 1 + } + ], + "id": 176, + "nodeType": "InlineAssembly", + "src": "3519:60095:0" + } + ] + }, + "functionSelector": "1e8e1e13", + "id": 178, + "implemented": true, + "kind": "function", + "modifiers": [], + "name": "verifyProof", + "nameLocation": "3401:11:0", + "nodeType": "FunctionDefinition", + "parameters": { + "id": 172, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 168, + "mutability": "mutable", + "name": "proof", + "nameLocation": "3437:5:0", + "nodeType": "VariableDeclaration", + "scope": 178, + "src": "3422:20:0", + "stateVariable": false, + "storageLocation": "calldata", + "typeDescriptions": { + "typeIdentifier": "t_bytes_calldata_ptr", + "typeString": "bytes" + }, + "typeName": { + "id": 167, + "name": "bytes", + "nodeType": "ElementaryTypeName", + "src": "3422:5:0", + "typeDescriptions": { + "typeIdentifier": "t_bytes_storage_ptr", + "typeString": "bytes" + } + }, + "visibility": "internal" + }, + { + "constant": false, + "id": 171, + "mutability": "mutable", + "name": "instances", + "nameLocation": "3471:9:0", + "nodeType": "VariableDeclaration", + "scope": 178, + "src": "3452:28:0", + "stateVariable": false, + "storageLocation": "calldata", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_uint256_$dyn_calldata_ptr", + "typeString": "uint256[]" + }, + "typeName": { + "baseType": { + "id": 169, + "name": "uint256", + "nodeType": "ElementaryTypeName", + "src": "3452:7:0", + "typeDescriptions": { + "typeIdentifier": "t_uint256", + "typeString": "uint256" + } + }, + "id": 170, + "nodeType": "ArrayTypeName", + "src": "3452:9:0", + "typeDescriptions": { + "typeIdentifier": "t_array$_t_uint256_$dyn_storage_ptr", + "typeString": "uint256[]" + } + }, + "visibility": "internal" + } + ], + "src": "3412:74:0" + }, + "returnParameters": { + "id": 175, + "nodeType": "ParameterList", + "parameters": [ + { + "constant": false, + "id": 174, + "mutability": "mutable", + "name": "", + "nameLocation": "-1:-1:-1", + "nodeType": "VariableDeclaration", + "scope": 178, + "src": "3503:4:0", + "stateVariable": false, + "storageLocation": "default", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + }, + "typeName": { + "id": 173, + "name": "bool", + "nodeType": "ElementaryTypeName", + "src": "3503:4:0", + "typeDescriptions": { + "typeIdentifier": "t_bool", + "typeString": "bool" + } + }, + "visibility": "internal" + } + ], + "src": "3502:6:0" + }, + "scope": 179, + "src": "3392:60228:0", + "stateMutability": "nonpayable", + "virtual": false, + "visibility": "public" + } + ], + "scope": 180, + "src": "58:63564:0", + "usedErrors": [], + "usedEvents": [] + } + ], + "src": "33:63589:0" + }, + "id": 0 +} diff --git a/compiled/Verifier.sol/Verifier.sol b/compiled/Verifier.sol/Verifier.sol new file mode 100644 index 0000000..7e912bc --- /dev/null +++ b/compiled/Verifier.sol/Verifier.sol @@ -0,0 +1,1622 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.0; + +contract Halo2Verifier { + uint256 internal constant PROOF_LEN_CPTR = 0x44; + uint256 internal constant PROOF_CPTR = 0x64; + uint256 internal constant NUM_INSTANCE_CPTR = 0x0ce4; + uint256 internal constant INSTANCE_CPTR = 0x0d04; + + uint256 internal constant FIRST_QUOTIENT_X_CPTR = 0x0424; + uint256 internal constant LAST_QUOTIENT_X_CPTR = 0x05e4; + + uint256 internal constant VK_MPTR = 0x06c0; + uint256 internal constant VK_DIGEST_MPTR = 0x06c0; + uint256 internal constant K_MPTR = 0x06e0; + uint256 internal constant N_INV_MPTR = 0x0700; + uint256 internal constant OMEGA_MPTR = 0x0720; + uint256 internal constant OMEGA_INV_MPTR = 0x0740; + uint256 internal constant OMEGA_INV_TO_L_MPTR = 0x0760; + uint256 internal constant NUM_INSTANCES_MPTR = 0x0780; + uint256 internal constant HAS_ACCUMULATOR_MPTR = 0x07a0; + uint256 internal constant ACC_OFFSET_MPTR = 0x07c0; + uint256 internal constant NUM_ACC_LIMBS_MPTR = 0x07e0; + uint256 internal constant NUM_ACC_LIMB_BITS_MPTR = 0x0800; + uint256 internal constant G1_X_MPTR = 0x0820; + uint256 internal constant G1_Y_MPTR = 0x0840; + uint256 internal constant G2_X_1_MPTR = 0x0860; + uint256 internal constant G2_X_2_MPTR = 0x0880; + uint256 internal constant G2_Y_1_MPTR = 0x08a0; + uint256 internal constant G2_Y_2_MPTR = 0x08c0; + uint256 internal constant NEG_S_G2_X_1_MPTR = 0x08e0; + uint256 internal constant NEG_S_G2_X_2_MPTR = 0x0900; + uint256 internal constant NEG_S_G2_Y_1_MPTR = 0x0920; + uint256 internal constant NEG_S_G2_Y_2_MPTR = 0x0940; + + uint256 internal constant CHALLENGE_MPTR = 0x0f60; + + uint256 internal constant THETA_MPTR = 0x0f60; + uint256 internal constant BETA_MPTR = 0x0f80; + uint256 internal constant GAMMA_MPTR = 0x0fa0; + uint256 internal constant Y_MPTR = 0x0fc0; + uint256 internal constant X_MPTR = 0x0fe0; + uint256 internal constant ZETA_MPTR = 0x1000; + uint256 internal constant NU_MPTR = 0x1020; + uint256 internal constant MU_MPTR = 0x1040; + + uint256 internal constant ACC_LHS_X_MPTR = 0x1060; + uint256 internal constant ACC_LHS_Y_MPTR = 0x1080; + uint256 internal constant ACC_RHS_X_MPTR = 0x10a0; + uint256 internal constant ACC_RHS_Y_MPTR = 0x10c0; + uint256 internal constant X_N_MPTR = 0x10e0; + uint256 internal constant X_N_MINUS_1_INV_MPTR = 0x1100; + uint256 internal constant L_LAST_MPTR = 0x1120; + uint256 internal constant L_BLIND_MPTR = 0x1140; + uint256 internal constant L_0_MPTR = 0x1160; + uint256 internal constant INSTANCE_EVAL_MPTR = 0x1180; + uint256 internal constant QUOTIENT_EVAL_MPTR = 0x11a0; + uint256 internal constant QUOTIENT_X_MPTR = 0x11c0; + uint256 internal constant QUOTIENT_Y_MPTR = 0x11e0; + uint256 internal constant R_EVAL_MPTR = 0x1200; + uint256 internal constant PAIRING_LHS_X_MPTR = 0x1220; + uint256 internal constant PAIRING_LHS_Y_MPTR = 0x1240; + uint256 internal constant PAIRING_RHS_X_MPTR = 0x1260; + uint256 internal constant PAIRING_RHS_Y_MPTR = 0x1280; + + function verifyProof( + bytes calldata proof, + uint256[] calldata instances + ) public returns (bool) { + assembly { + // Read EC point (x, y) at (proof_cptr, proof_cptr + 0x20), + // and check if the point is on affine plane, + // and store them in (hash_mptr, hash_mptr + 0x20). + // Return updated (success, proof_cptr, hash_mptr). + function read_ec_point(success, proof_cptr, hash_mptr, q) -> ret0, ret1, ret2 { + let x := calldataload(proof_cptr) + let y := calldataload(add(proof_cptr, 0x20)) + ret0 := and(success, lt(x, q)) + ret0 := and(ret0, lt(y, q)) + ret0 := and(ret0, eq(mulmod(y, y, q), addmod(mulmod(x, mulmod(x, x, q), q), 3, q))) + mstore(hash_mptr, x) + mstore(add(hash_mptr, 0x20), y) + ret1 := add(proof_cptr, 0x40) + ret2 := add(hash_mptr, 0x40) + } + + // Squeeze challenge by keccak256(memory[0..hash_mptr]), + // and store hash mod r as challenge in challenge_mptr, + // and push back hash in 0x00 as the first input for next squeeze. + // Return updated (challenge_mptr, hash_mptr). + function squeeze_challenge(challenge_mptr, hash_mptr, r) -> ret0, ret1 { + let hash := keccak256(0x00, hash_mptr) + mstore(challenge_mptr, mod(hash, r)) + mstore(0x00, hash) + ret0 := add(challenge_mptr, 0x20) + ret1 := 0x20 + } + + // Squeeze challenge without absorbing new input from calldata, + // by putting an extra 0x01 in memory[0x20] and squeeze by keccak256(memory[0..21]), + // and store hash mod r as challenge in challenge_mptr, + // and push back hash in 0x00 as the first input for next squeeze. + // Return updated (challenge_mptr). + function squeeze_challenge_cont(challenge_mptr, r) -> ret { + mstore8(0x20, 0x01) + let hash := keccak256(0x00, 0x21) + mstore(challenge_mptr, mod(hash, r)) + mstore(0x00, hash) + ret := add(challenge_mptr, 0x20) + } + + // Batch invert values in memory[mptr_start..mptr_end] in place. + // Return updated (success). + function batch_invert(success, mptr_start, mptr_end, r) -> ret { + let gp_mptr := mptr_end + let gp := mload(mptr_start) + let mptr := add(mptr_start, 0x20) + for + {} + lt(mptr, sub(mptr_end, 0x20)) + {} + { + gp := mulmod(gp, mload(mptr), r) + mstore(gp_mptr, gp) + mptr := add(mptr, 0x20) + gp_mptr := add(gp_mptr, 0x20) + } + gp := mulmod(gp, mload(mptr), r) + + mstore(gp_mptr, 0x20) + mstore(add(gp_mptr, 0x20), 0x20) + mstore(add(gp_mptr, 0x40), 0x20) + mstore(add(gp_mptr, 0x60), gp) + mstore(add(gp_mptr, 0x80), sub(r, 2)) + mstore(add(gp_mptr, 0xa0), r) + ret := and(success, staticcall(gas(), 0x05, gp_mptr, 0xc0, gp_mptr, 0x20)) + let all_inv := mload(gp_mptr) + + let first_mptr := mptr_start + let second_mptr := add(first_mptr, 0x20) + gp_mptr := sub(gp_mptr, 0x20) + for + {} + lt(second_mptr, mptr) + {} + { + let inv := mulmod(all_inv, mload(gp_mptr), r) + all_inv := mulmod(all_inv, mload(mptr), r) + mstore(mptr, inv) + mptr := sub(mptr, 0x20) + gp_mptr := sub(gp_mptr, 0x20) + } + let inv_first := mulmod(all_inv, mload(second_mptr), r) + let inv_second := mulmod(all_inv, mload(first_mptr), r) + mstore(first_mptr, inv_first) + mstore(second_mptr, inv_second) + } + + // Add (x, y) into point at (0x00, 0x20). + // Return updated (success). + function ec_add_acc(success, x, y) -> ret { + mstore(0x40, x) + mstore(0x60, y) + ret := and(success, staticcall(gas(), 0x06, 0x00, 0x80, 0x00, 0x40)) + } + + // Scale point at (0x00, 0x20) by scalar. + function ec_mul_acc(success, scalar) -> ret { + mstore(0x40, scalar) + ret := and(success, staticcall(gas(), 0x07, 0x00, 0x60, 0x00, 0x40)) + } + + // Add (x, y) into point at (0x80, 0xa0). + // Return updated (success). + function ec_add_tmp(success, x, y) -> ret { + mstore(0xc0, x) + mstore(0xe0, y) + ret := and(success, staticcall(gas(), 0x06, 0x80, 0x80, 0x80, 0x40)) + } + + // Scale point at (0x80, 0xa0) by scalar. + // Return updated (success). + function ec_mul_tmp(success, scalar) -> ret { + mstore(0xc0, scalar) + ret := and(success, staticcall(gas(), 0x07, 0x80, 0x60, 0x80, 0x40)) + } + + // Perform pairing check. + // Return updated (success). + function ec_pairing(success, lhs_x, lhs_y, rhs_x, rhs_y) -> ret { + mstore(0x00, lhs_x) + mstore(0x20, lhs_y) + mstore(0x40, mload(G2_X_1_MPTR)) + mstore(0x60, mload(G2_X_2_MPTR)) + mstore(0x80, mload(G2_Y_1_MPTR)) + mstore(0xa0, mload(G2_Y_2_MPTR)) + mstore(0xc0, rhs_x) + mstore(0xe0, rhs_y) + mstore(0x100, mload(NEG_S_G2_X_1_MPTR)) + mstore(0x120, mload(NEG_S_G2_X_2_MPTR)) + mstore(0x140, mload(NEG_S_G2_Y_1_MPTR)) + mstore(0x160, mload(NEG_S_G2_Y_2_MPTR)) + ret := and(success, staticcall(gas(), 0x08, 0x00, 0x180, 0x00, 0x20)) + ret := and(ret, mload(0x00)) + } + + // Modulus + let q := 21888242871839275222246405745257275088696311157297823662689037894645226208583 // BN254 base field + let r := 21888242871839275222246405745257275088548364400416034343698204186575808495617 // BN254 scalar field + + // Initialize success as true + let success := true + + { + // Load vk into memory + mstore(0x06c0, 0x0ae5a4c87fb4103b0474b36e02a3098cfd57ce027aa1127070f9f37f5cada089) // vk_digest + mstore(0x06e0, 0x0000000000000000000000000000000000000000000000000000000000000010) // k + mstore(0x0700, 0x30641e0e92bebef818268d663bcad6dbcfd6c0149170f6d7d350b1b1fa6c1001) // n_inv + mstore(0x0720, 0x09d2cc4b5782fbe923e49ace3f647643a5f5d8fb89091c3ababd582133584b29) // omega + mstore(0x0740, 0x0cf312e84f2456134e812826473d3dfb577b2bfdba762aba88b47b740472c1f0) // omega_inv + mstore(0x0760, 0x17cbd779ed6ea1b8e9dbcde0345b2cfdb96e80bea0dd1318bdd0e183a00e0492) // omega_inv_to_l + mstore(0x0780, 0x0000000000000000000000000000000000000000000000000000000000000002) // num_instances + mstore(0x07a0, 0x0000000000000000000000000000000000000000000000000000000000000000) // has_accumulator + mstore(0x07c0, 0x0000000000000000000000000000000000000000000000000000000000000000) // acc_offset + mstore(0x07e0, 0x0000000000000000000000000000000000000000000000000000000000000000) // num_acc_limbs + mstore(0x0800, 0x0000000000000000000000000000000000000000000000000000000000000000) // num_acc_limb_bits + mstore(0x0820, 0x0000000000000000000000000000000000000000000000000000000000000001) // g1_x + mstore(0x0840, 0x0000000000000000000000000000000000000000000000000000000000000002) // g1_y + mstore(0x0860, 0x198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c2) // g2_x_1 + mstore(0x0880, 0x1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed) // g2_x_2 + mstore(0x08a0, 0x090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b) // g2_y_1 + mstore(0x08c0, 0x12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa) // g2_y_2 + mstore(0x08e0, 0x186282957db913abd99f91db59fe69922e95040603ef44c0bd7aa3adeef8f5ac) // neg_s_g2_x_1 + mstore(0x0900, 0x17944351223333f260ddc3b4af45191b856689eda9eab5cbcddbbe570ce860d2) // neg_s_g2_x_2 + mstore(0x0920, 0x06d971ff4a7467c3ec596ed6efc674572e32fd6f52b721f97e35b0b3d3546753) // neg_s_g2_y_1 + mstore(0x0940, 0x06ecdb9f9567f59ed2eee36e1e1d58797fd13cc97fafc2910f5e8a12f202fa9a) // neg_s_g2_y_2 + mstore(0x0960, 0x210158638dee451e534ca110fc31daf414782bec22ace8deda119e2973873bc1) // fixed_comms[0].x + mstore(0x0980, 0x241019be3d408241c697fe490965af44c0359262b017371a9323e30c496564b4) // fixed_comms[0].y + mstore(0x09a0, 0x29e8e775ce84508305d23a5baf9e7221a162af2702fc6defe9866e45bb4bbcd9) // fixed_comms[1].x + mstore(0x09c0, 0x08c60ca3c56df01dc9bec33189e4689b04023002d24b67d057cb258f585ee564) // fixed_comms[1].y + mstore(0x09e0, 0x2fa37d05e9d3dae99a6aae909d08ec31ff241bc5f66eb2ff132ef36e3ed98099) // fixed_comms[2].x + mstore(0x0a00, 0x15fc9b4a39f85774b22344bbdedc9cf7008fb687a123746b19286793ed75cca3) // fixed_comms[2].y + mstore(0x0a20, 0x1f064961101aac429edf8abc2ef15cc130e75f51b7f3a2c46940e65ae93b201d) // fixed_comms[3].x + mstore(0x0a40, 0x03524af19a65d5b32cc6060fce0d53229180ff08041bf3c7aefdb70878e76200) // fixed_comms[3].y + mstore(0x0a60, 0x0c8b6487a2f59fd7e1d1f3988f61bab968a4d1061f2666b08591b677f1258f62) // fixed_comms[4].x + mstore(0x0a80, 0x2c675bb5db47e0a6a65b7df8396c44faa4ebe44dadf93e5130b9f97682c34395) // fixed_comms[4].y + mstore(0x0aa0, 0x2cdd59160fb54c7952431f7e0a8ef998dd48ca772ea89c51cb8b0ba45d2405aa) // fixed_comms[5].x + mstore(0x0ac0, 0x1dc088b956d7fcbd917ca8a5fa2e246e7563a15754c10183ad99098930a6278a) // fixed_comms[5].y + mstore(0x0ae0, 0x2490aa617abc1bb6328ccc836f0aba10993b4521eac94709c9f6b67de36ebfe3) // fixed_comms[6].x + mstore(0x0b00, 0x0c3215edaf5e3f4eb69ac2d2b617c5a966489df89f1fc0e46f381377ffcfd68c) // fixed_comms[6].y + mstore(0x0b20, 0x2032d5131dee7fe76191b84e49a98f07646f904f24637350b1395ef132d7517b) // fixed_comms[7].x + mstore(0x0b40, 0x2627d23016719c05b2ce555e4dfc2b7fa30c124c594648d8bfa2ae5a750f261e) // fixed_comms[7].y + mstore(0x0b60, 0x25c735898c41a6be70972861480d514a320b949f8913b5e4d161fc750acafa08) // fixed_comms[8].x + mstore(0x0b80, 0x02d16a0d959e7cc34a3996bc14e6ff9dab8bcf9bb825a2e9ac22e17fac3b49ca) // fixed_comms[8].y + mstore(0x0ba0, 0x070579580ec1629f98a8811ba4d83445315216338f6c38cb8592aab5b1e271e9) // fixed_comms[9].x + mstore(0x0bc0, 0x01f68299fc5e0efa355203f4434e9f66989580084adbf24bf5d793718eeaae1b) // fixed_comms[9].y + mstore(0x0be0, 0x2ace5e4438d8115a669f3336e61bfd1a89f69c7422a9cd34dfd108160a9923db) // fixed_comms[10].x + mstore(0x0c00, 0x11d91245b34a6a9f5764157f1018fcb2fe90792063a0eb8774c545df09f2688c) // fixed_comms[10].y + mstore(0x0c20, 0x22c96a7591c2f6edfbfa178152a68b018b71eec65ec208eb6e2bbf91a4945a79) // fixed_comms[11].x + mstore(0x0c40, 0x214a80d1b409978948041daa3cc2eecdafe649277c703e9589d3007ca58973b5) // fixed_comms[11].y + mstore(0x0c60, 0x1a601b7f675c4fe73fe0bf9918f89cb969bd3040d57e9504b34e655175c67410) // fixed_comms[12].x + mstore(0x0c80, 0x26f1947f802dba63b59e6c04136ac05291b7e16d722624c17cfcc770239f2e8e) // fixed_comms[12].y + mstore(0x0ca0, 0x119e73e1a59373a98f488ee84c48656268297e0505746cd80c37263242c34936) // fixed_comms[13].x + mstore(0x0cc0, 0x179c386c3700be5d23f4eeb24f00a0f8472555a8d1f1a7eff95baeeeaef9e70b) // fixed_comms[13].y + mstore(0x0ce0, 0x112d52058b92c0d9aa456b67fe453e0981a5553569f87d5ba7102973bd0d33de) // fixed_comms[14].x + mstore(0x0d00, 0x0f2682ed5aca4f8d0602c2dce2f50df6888903213c5157f9ae2713d9bfe465ec) // fixed_comms[14].y + mstore(0x0d20, 0x2c440cbc47a5bbff677fc24d1281ac43d61a62fcbd1caa4085a37a088f79a926) // permutation_comms[0].x + mstore(0x0d40, 0x2315ddf7620b6aa6b478d24ad2e968eda3829d03d1bf1bf0174c19dba75be88e) // permutation_comms[0].y + mstore(0x0d60, 0x0ffeb7fbdfdc7aab4eec03154891297394e3e3649f398e349476651371b4067d) // permutation_comms[1].x + mstore(0x0d80, 0x2ecff97abf5acfe64c9e69fd28922c718357a7e13efee5227384f3753eb869e5) // permutation_comms[1].y + mstore(0x0da0, 0x044ac3fb938c1db4c36700f4409178241f6e4a9e68e207b2d6637748b1cc67cf) // permutation_comms[2].x + mstore(0x0dc0, 0x1de04e04cbc29e79f7d9207c362a7b426037067d8bd9f08887c37b9cf6b60999) // permutation_comms[2].y + mstore(0x0de0, 0x0b1851f4bf6f1f521924f5a96c12ed415b10ea76b9328ba2f63e29897ed90229) // permutation_comms[3].x + mstore(0x0e00, 0x11b40547dbdf4da6b179398f058e3b0cbe820088f72df45d8da0f6ba8f215bce) // permutation_comms[3].y + mstore(0x0e20, 0x12ea0919232cd844421c9228f7e6703d0d699b7e4cea4c2dc4db54c2254dc817) // permutation_comms[4].x + mstore(0x0e40, 0x2b462d68c894d2a421d5243cf88c291138131a0e49d97ec8b01ceb3121e35c99) // permutation_comms[4].y + mstore(0x0e60, 0x28103ab59e64b227f453fdf78adb3582f1d0782f3ee84fcca940aeb46853d0a1) // permutation_comms[5].x + mstore(0x0e80, 0x1581f7cc3103852df74d7fb9ea86b6912669f4233dbc144ec2283505a18fe12b) // permutation_comms[5].y + mstore(0x0ea0, 0x0a7996aa36917b2d360c2b7483d55745e68081d52528c518c61e34ae6ae959de) // permutation_comms[6].x + mstore(0x0ec0, 0x0008bebe37e9ab56bb961edd911f65d07f60860309390fe53e4d0b0894b8ea42) // permutation_comms[6].y + mstore(0x0ee0, 0x2cd17e5f3e3e213aa5d5f906882690d71254aa1d72e37c60a95c1a9eaad90239) // permutation_comms[7].x + mstore(0x0f00, 0x0bbef341c6c6abea51c9eadf42304f6328fad70bdd0ad2b848bacfcb1990bcc1) // permutation_comms[7].y + mstore(0x0f20, 0x01a7837e6470babb230978a3079af34e382588caaf1c0c791e81f37222798929) // permutation_comms[8].x + mstore(0x0f40, 0x155c9bea95acf37b018196229c82254163940010ab902b96a4dcde67c6a99a6f) // permutation_comms[8].y + + // Check valid length of proof + success := and(success, eq(0x0c80, calldataload(PROOF_LEN_CPTR))) + + // Check valid length of instances + let num_instances := mload(NUM_INSTANCES_MPTR) + success := and(success, eq(num_instances, calldataload(NUM_INSTANCE_CPTR))) + + // Absorb vk diegst + mstore(0x00, mload(VK_DIGEST_MPTR)) + + // Read instances and witness commitments and generate challenges + let hash_mptr := 0x20 + let instance_cptr := INSTANCE_CPTR + for + { let instance_cptr_end := add(instance_cptr, mul(0x20, num_instances)) } + lt(instance_cptr, instance_cptr_end) + {} + { + let instance := calldataload(instance_cptr) + success := and(success, lt(instance, r)) + mstore(hash_mptr, instance) + instance_cptr := add(instance_cptr, 0x20) + hash_mptr := add(hash_mptr, 0x20) + } + + let proof_cptr := PROOF_CPTR + let challenge_mptr := CHALLENGE_MPTR + + // Phase 1 + for + { let proof_cptr_end := add(proof_cptr, 0x0180) } + lt(proof_cptr, proof_cptr_end) + {} + { + success, proof_cptr, hash_mptr := read_ec_point(success, proof_cptr, hash_mptr, q) + } + + challenge_mptr, hash_mptr := squeeze_challenge(challenge_mptr, hash_mptr, r) + + // Phase 2 + for + { let proof_cptr_end := add(proof_cptr, 0xc0) } + lt(proof_cptr, proof_cptr_end) + {} + { + success, proof_cptr, hash_mptr := read_ec_point(success, proof_cptr, hash_mptr, q) + } + + challenge_mptr, hash_mptr := squeeze_challenge(challenge_mptr, hash_mptr, r) + challenge_mptr := squeeze_challenge_cont(challenge_mptr, r) + + // Phase 3 + for + { let proof_cptr_end := add(proof_cptr, 0x0180) } + lt(proof_cptr, proof_cptr_end) + {} + { + success, proof_cptr, hash_mptr := read_ec_point(success, proof_cptr, hash_mptr, q) + } + + challenge_mptr, hash_mptr := squeeze_challenge(challenge_mptr, hash_mptr, r) + + // Phase 4 + for + { let proof_cptr_end := add(proof_cptr, 0x0200) } + lt(proof_cptr, proof_cptr_end) + {} + { + success, proof_cptr, hash_mptr := read_ec_point(success, proof_cptr, hash_mptr, q) + } + + challenge_mptr, hash_mptr := squeeze_challenge(challenge_mptr, hash_mptr, r) + + // Read evaluations + for + { let proof_cptr_end := add(proof_cptr, 0x0640) } + lt(proof_cptr, proof_cptr_end) + {} + { + let eval := calldataload(proof_cptr) + success := and(success, lt(eval, r)) + mstore(hash_mptr, eval) + proof_cptr := add(proof_cptr, 0x20) + hash_mptr := add(hash_mptr, 0x20) + } + + // Read batch opening proof and generate challenges + challenge_mptr, hash_mptr := squeeze_challenge(challenge_mptr, hash_mptr, r) // zeta + challenge_mptr := squeeze_challenge_cont(challenge_mptr, r) // nu + + success, proof_cptr, hash_mptr := read_ec_point(success, proof_cptr, hash_mptr, q) // W + + challenge_mptr, hash_mptr := squeeze_challenge(challenge_mptr, hash_mptr, r) // mu + + success, proof_cptr, hash_mptr := read_ec_point(success, proof_cptr, hash_mptr, q) // W' + + // Read accumulator from instances + if mload(HAS_ACCUMULATOR_MPTR) { + let num_limbs := mload(NUM_ACC_LIMBS_MPTR) + let num_limb_bits := mload(NUM_ACC_LIMB_BITS_MPTR) + + let cptr := add(INSTANCE_CPTR, mul(mload(ACC_OFFSET_MPTR), 0x20)) + let lhs_y_off := mul(num_limbs, 0x20) + let rhs_x_off := mul(lhs_y_off, 2) + let rhs_y_off := mul(lhs_y_off, 3) + let lhs_x := calldataload(cptr) + let lhs_y := calldataload(add(cptr, lhs_y_off)) + let rhs_x := calldataload(add(cptr, rhs_x_off)) + let rhs_y := calldataload(add(cptr, rhs_y_off)) + for + { + let cptr_end := add(cptr, mul(0x20, num_limbs)) + let shift := num_limb_bits + } + lt(cptr, cptr_end) + {} + { + cptr := add(cptr, 0x20) + lhs_x := add(lhs_x, shl(shift, calldataload(cptr))) + lhs_y := add(lhs_y, shl(shift, calldataload(add(cptr, lhs_y_off)))) + rhs_x := add(rhs_x, shl(shift, calldataload(add(cptr, rhs_x_off)))) + rhs_y := add(rhs_y, shl(shift, calldataload(add(cptr, rhs_y_off)))) + shift := add(shift, num_limb_bits) + } + + success := and(success, eq(mulmod(lhs_y, lhs_y, q), addmod(mulmod(lhs_x, mulmod(lhs_x, lhs_x, q), q), 3, q))) + success := and(success, eq(mulmod(rhs_y, rhs_y, q), addmod(mulmod(rhs_x, mulmod(rhs_x, rhs_x, q), q), 3, q))) + + mstore(ACC_LHS_X_MPTR, lhs_x) + mstore(ACC_LHS_Y_MPTR, lhs_y) + mstore(ACC_RHS_X_MPTR, rhs_x) + mstore(ACC_RHS_Y_MPTR, rhs_y) + } + + pop(q) + } + + // Revert earlier if anything from calldata is invalid + if iszero(success) { + revert(0, 0) + } + + // Compute lagrange evaluations and instance evaluation + { + let k := mload(K_MPTR) + let x := mload(X_MPTR) + let x_n := x + for + { let idx := 0 } + lt(idx, k) + { idx := add(idx, 1) } + { + x_n := mulmod(x_n, x_n, r) + } + + let omega := mload(OMEGA_MPTR) + + let mptr := X_N_MPTR + let mptr_end := add(mptr, mul(0x20, add(mload(NUM_INSTANCES_MPTR), 6))) + for + { let pow_of_omega := mload(OMEGA_INV_TO_L_MPTR) } + lt(mptr, mptr_end) + { mptr := add(mptr, 0x20) } + { + mstore(mptr, addmod(x, sub(r, pow_of_omega), r)) + pow_of_omega := mulmod(pow_of_omega, omega, r) + } + let x_n_minus_1 := addmod(x_n, sub(r, 1), r) + mstore(mptr_end, x_n_minus_1) + success := batch_invert(success, X_N_MPTR, add(mptr_end, 0x20), r) + + mptr := X_N_MPTR + let l_i_common := mulmod(x_n_minus_1, mload(N_INV_MPTR), r) + for + { let pow_of_omega := mload(OMEGA_INV_TO_L_MPTR) } + lt(mptr, mptr_end) + { mptr := add(mptr, 0x20) } + { + mstore(mptr, mulmod(l_i_common, mulmod(mload(mptr), pow_of_omega, r), r)) + pow_of_omega := mulmod(pow_of_omega, omega, r) + } + + let l_blind := mload(add(X_N_MPTR, 0x20)) + let l_i_cptr := add(X_N_MPTR, 0x40) + for + { let l_i_cptr_end := add(X_N_MPTR, 0xc0) } + lt(l_i_cptr, l_i_cptr_end) + { l_i_cptr := add(l_i_cptr, 0x20) } + { + l_blind := addmod(l_blind, mload(l_i_cptr), r) + } + + let instance_eval := mulmod(mload(l_i_cptr), calldataload(INSTANCE_CPTR), r) + let instance_cptr := add(INSTANCE_CPTR, 0x20) + l_i_cptr := add(l_i_cptr, 0x20) + for + { let instance_cptr_end := add(INSTANCE_CPTR, mul(0x20, mload(NUM_INSTANCES_MPTR))) } + lt(instance_cptr, instance_cptr_end) + { + instance_cptr := add(instance_cptr, 0x20) + l_i_cptr := add(l_i_cptr, 0x20) + } + { + instance_eval := addmod(instance_eval, mulmod(mload(l_i_cptr), calldataload(instance_cptr), r), r) + } + + let x_n_minus_1_inv := mload(mptr_end) + let l_last := mload(X_N_MPTR) + let l_0 := mload(add(X_N_MPTR, 0xc0)) + + mstore(X_N_MPTR, x_n) + mstore(X_N_MINUS_1_INV_MPTR, x_n_minus_1_inv) + mstore(L_LAST_MPTR, l_last) + mstore(L_BLIND_MPTR, l_blind) + mstore(L_0_MPTR, l_0) + mstore(INSTANCE_EVAL_MPTR, instance_eval) + } + + // Compute quotient evavluation + { + let quotient_eval_numer + let delta := 4131629893567559867359510883348571134090853742863529169391034518566172092834 + let y := mload(Y_MPTR) + { + let f_12 := calldataload(0x0904) + let var0 := 0x2 + let var1 := sub(r, f_12) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_12, var2, r) + let var4 := 0x3 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x4 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let a_3 := calldataload(0x0684) + let f_1 := calldataload(0x07e4) + let var10 := addmod(a_3, f_1, r) + let var11 := mulmod(var10, var10, r) + let var12 := mulmod(var11, var11, r) + let var13 := mulmod(var12, var10, r) + let var14 := mulmod(var13, 0x066f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5, r) + let a_4 := calldataload(0x06a4) + let f_2 := calldataload(0x0804) + let var15 := addmod(a_4, f_2, r) + let var16 := mulmod(var15, var15, r) + let var17 := mulmod(var16, var16, r) + let var18 := mulmod(var17, var15, r) + let var19 := mulmod(var18, 0x2b9d4b4110c9ae997782e1509b1d0fdb20a7c02bbd8bea7305462b9f8125b1e8, r) + let var20 := addmod(var14, var19, r) + let a_3_next_1 := calldataload(0x06c4) + let var21 := sub(r, a_3_next_1) + let var22 := addmod(var20, var21, r) + let var23 := mulmod(var9, var22, r) + quotient_eval_numer := var23 + } + { + let f_12 := calldataload(0x0904) + let var0 := 0x2 + let var1 := sub(r, f_12) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_12, var2, r) + let var4 := 0x3 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x4 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let a_3 := calldataload(0x0684) + let f_1 := calldataload(0x07e4) + let var10 := addmod(a_3, f_1, r) + let var11 := mulmod(var10, var10, r) + let var12 := mulmod(var11, var11, r) + let var13 := mulmod(var12, var10, r) + let var14 := mulmod(var13, 0x0cc57cdbb08507d62bf67a4493cc262fb6c09d557013fff1f573f431221f8ff9, r) + let a_4 := calldataload(0x06a4) + let f_2 := calldataload(0x0804) + let var15 := addmod(a_4, f_2, r) + let var16 := mulmod(var15, var15, r) + let var17 := mulmod(var16, var16, r) + let var18 := mulmod(var17, var15, r) + let var19 := mulmod(var18, 0x1274e649a32ed355a31a6ed69724e1adade857e86eb5c3a121bcd147943203c8, r) + let var20 := addmod(var14, var19, r) + let a_4_next_1 := calldataload(0x06e4) + let var21 := sub(r, a_4_next_1) + let var22 := addmod(var20, var21, r) + let var23 := mulmod(var9, var22, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var23, r) + } + { + let f_12 := calldataload(0x0904) + let var0 := 0x1 + let var1 := sub(r, f_12) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_12, var2, r) + let var4 := 0x3 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x4 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let a_3 := calldataload(0x0684) + let f_1 := calldataload(0x07e4) + let var10 := addmod(a_3, f_1, r) + let var11 := mulmod(var10, var10, r) + let var12 := mulmod(var11, var11, r) + let var13 := mulmod(var12, var10, r) + let a_5 := calldataload(0x0704) + let var14 := sub(r, a_5) + let var15 := addmod(var13, var14, r) + let var16 := mulmod(var9, var15, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var16, r) + } + { + let f_12 := calldataload(0x0904) + let var0 := 0x1 + let var1 := sub(r, f_12) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_12, var2, r) + let var4 := 0x3 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x4 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let a_5 := calldataload(0x0704) + let var10 := mulmod(a_5, 0x066f6f85d6f68a85ec10345351a23a3aaf07f38af8c952a7bceca70bd2af7ad5, r) + let a_4 := calldataload(0x06a4) + let f_2 := calldataload(0x0804) + let var11 := addmod(a_4, f_2, r) + let var12 := mulmod(var11, 0x2b9d4b4110c9ae997782e1509b1d0fdb20a7c02bbd8bea7305462b9f8125b1e8, r) + let var13 := addmod(var10, var12, r) + let f_3 := calldataload(0x07a4) + let var14 := addmod(var13, f_3, r) + let var15 := mulmod(var14, var14, r) + let var16 := mulmod(var15, var15, r) + let var17 := mulmod(var16, var14, r) + let a_3_next_1 := calldataload(0x06c4) + let var18 := mulmod(a_3_next_1, 0x13abec390ada7f4370819ab1c7846f210554569d9b29d1ea8dbebd0fa8c53e66, r) + let a_4_next_1 := calldataload(0x06e4) + let var19 := mulmod(a_4_next_1, 0x1eb9e1dc19a33a624c9862a1d97d1510bd521ead5dfe0345aaf6185b1a1e60fe, r) + let var20 := addmod(var18, var19, r) + let var21 := sub(r, var20) + let var22 := addmod(var17, var21, r) + let var23 := mulmod(var9, var22, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var23, r) + } + { + let f_12 := calldataload(0x0904) + let var0 := 0x1 + let var1 := sub(r, f_12) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_12, var2, r) + let var4 := 0x3 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x4 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let a_5 := calldataload(0x0704) + let var10 := mulmod(a_5, 0x0cc57cdbb08507d62bf67a4493cc262fb6c09d557013fff1f573f431221f8ff9, r) + let a_4 := calldataload(0x06a4) + let f_2 := calldataload(0x0804) + let var11 := addmod(a_4, f_2, r) + let var12 := mulmod(var11, 0x1274e649a32ed355a31a6ed69724e1adade857e86eb5c3a121bcd147943203c8, r) + let var13 := addmod(var10, var12, r) + let f_4 := calldataload(0x07c4) + let var14 := addmod(var13, f_4, r) + let a_3_next_1 := calldataload(0x06c4) + let var15 := mulmod(a_3_next_1, 0x0fc1c9394db89bb2601abc49fdad4f038ce5169030a2ad69763f7875036bcb02, r) + let a_4_next_1 := calldataload(0x06e4) + let var16 := mulmod(a_4_next_1, 0x16a9e98c493a902b9502054edc03e7b22b7eac34345961bc8abced6bd147c8be, r) + let var17 := addmod(var15, var16, r) + let var18 := sub(r, var17) + let var19 := addmod(var14, var18, r) + let var20 := mulmod(var9, var19, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var20, r) + } + { + let f_12 := calldataload(0x0904) + let var0 := 0x1 + let var1 := sub(r, f_12) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_12, var2, r) + let var4 := 0x2 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x4 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let a_3_prev_1 := calldataload(0x0744) + let a_3 := calldataload(0x0684) + let var10 := addmod(a_3_prev_1, a_3, r) + let a_3_next_1 := calldataload(0x06c4) + let var11 := sub(r, a_3_next_1) + let var12 := addmod(var10, var11, r) + let var13 := mulmod(var9, var12, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var13, r) + } + { + let f_12 := calldataload(0x0904) + let var0 := 0x1 + let var1 := sub(r, f_12) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_12, var2, r) + let var4 := 0x2 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x4 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let a_4_prev_1 := calldataload(0x0724) + let a_4_next_1 := calldataload(0x06e4) + let var10 := sub(r, a_4_next_1) + let var11 := addmod(a_4_prev_1, var10, r) + let var12 := mulmod(var9, var11, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var12, r) + } + { + let f_13 := calldataload(0x0924) + let var0 := 0x1 + let var1 := sub(r, f_13) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_13, var2, r) + let var4 := 0x3 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x4 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let var10 := 0x5 + let var11 := addmod(var10, var1, r) + let var12 := mulmod(var9, var11, r) + let var13 := 0x6 + let var14 := addmod(var13, var1, r) + let var15 := mulmod(var12, var14, r) + let var16 := 0x7 + let var17 := addmod(var16, var1, r) + let var18 := mulmod(var15, var17, r) + let a_2 := calldataload(0x0664) + let a_0 := calldataload(0x0624) + let a_1 := calldataload(0x0644) + let var19 := mulmod(a_0, a_1, r) + let a_2_prev_1 := calldataload(0x0764) + let var20 := addmod(var19, a_2_prev_1, r) + let var21 := sub(r, var20) + let var22 := addmod(a_2, var21, r) + let var23 := mulmod(var18, var22, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var23, r) + } + { + let f_13 := calldataload(0x0924) + let var0 := 0x1 + let var1 := sub(r, f_13) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_13, var2, r) + let var4 := 0x2 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x4 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let var10 := 0x5 + let var11 := addmod(var10, var1, r) + let var12 := mulmod(var9, var11, r) + let var13 := 0x6 + let var14 := addmod(var13, var1, r) + let var15 := mulmod(var12, var14, r) + let var16 := 0x7 + let var17 := addmod(var16, var1, r) + let var18 := mulmod(var15, var17, r) + let a_2 := calldataload(0x0664) + let a_1 := calldataload(0x0644) + let a_2_prev_1 := calldataload(0x0764) + let var19 := mulmod(a_1, a_2_prev_1, r) + let var20 := sub(r, var19) + let var21 := addmod(a_2, var20, r) + let var22 := mulmod(var18, var21, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var22, r) + } + { + let f_14 := calldataload(0x0944) + let var0 := 0x2 + let var1 := sub(r, f_14) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_14, var2, r) + let a_2 := calldataload(0x0664) + let a_1 := calldataload(0x0644) + let var4 := sub(r, a_1) + let var5 := addmod(a_2, var4, r) + let var6 := mulmod(var3, var5, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var6, r) + } + { + let f_12 := calldataload(0x0904) + let var0 := 0x1 + let var1 := sub(r, f_12) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_12, var2, r) + let var4 := 0x2 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x3 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let a_2 := calldataload(0x0664) + let a_0 := calldataload(0x0624) + let a_1 := calldataload(0x0644) + let var10 := addmod(a_0, a_1, r) + let var11 := sub(r, var10) + let var12 := addmod(a_2, var11, r) + let var13 := mulmod(var9, var12, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var13, r) + } + { + let f_13 := calldataload(0x0924) + let var0 := 0x1 + let var1 := sub(r, f_13) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_13, var2, r) + let var4 := 0x2 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x3 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let var10 := 0x4 + let var11 := addmod(var10, var1, r) + let var12 := mulmod(var9, var11, r) + let var13 := 0x5 + let var14 := addmod(var13, var1, r) + let var15 := mulmod(var12, var14, r) + let var16 := 0x7 + let var17 := addmod(var16, var1, r) + let var18 := mulmod(var15, var17, r) + let a_2 := calldataload(0x0664) + let a_0 := calldataload(0x0624) + let a_1 := calldataload(0x0644) + let var19 := mulmod(a_0, a_1, r) + let var20 := sub(r, var19) + let var21 := addmod(a_2, var20, r) + let var22 := mulmod(var18, var21, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var22, r) + } + { + let f_13 := calldataload(0x0924) + let var0 := 0x2 + let var1 := sub(r, f_13) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_13, var2, r) + let var4 := 0x3 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x4 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let var10 := 0x5 + let var11 := addmod(var10, var1, r) + let var12 := mulmod(var9, var11, r) + let var13 := 0x6 + let var14 := addmod(var13, var1, r) + let var15 := mulmod(var12, var14, r) + let var16 := 0x7 + let var17 := addmod(var16, var1, r) + let var18 := mulmod(var15, var17, r) + let a_2 := calldataload(0x0664) + let a_0 := calldataload(0x0624) + let a_1 := calldataload(0x0644) + let var19 := sub(r, a_1) + let var20 := addmod(a_0, var19, r) + let var21 := sub(r, var20) + let var22 := addmod(a_2, var21, r) + let var23 := mulmod(var18, var22, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var23, r) + } + { + let f_13 := calldataload(0x0924) + let var0 := 0x1 + let var1 := sub(r, f_13) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_13, var2, r) + let var4 := 0x2 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x3 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let var10 := 0x5 + let var11 := addmod(var10, var1, r) + let var12 := mulmod(var9, var11, r) + let var13 := 0x6 + let var14 := addmod(var13, var1, r) + let var15 := mulmod(var12, var14, r) + let var16 := 0x7 + let var17 := addmod(var16, var1, r) + let var18 := mulmod(var15, var17, r) + let a_2 := calldataload(0x0664) + let a_1 := calldataload(0x0644) + let a_2_prev_1 := calldataload(0x0764) + let var19 := addmod(a_1, a_2_prev_1, r) + let var20 := sub(r, var19) + let var21 := addmod(a_2, var20, r) + let var22 := mulmod(var18, var21, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var22, r) + } + { + let f_13 := calldataload(0x0924) + let var0 := 0x1 + let var1 := sub(r, f_13) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_13, var2, r) + let var4 := 0x2 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x3 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let var10 := 0x4 + let var11 := addmod(var10, var1, r) + let var12 := mulmod(var9, var11, r) + let var13 := 0x6 + let var14 := addmod(var13, var1, r) + let var15 := mulmod(var12, var14, r) + let var16 := 0x7 + let var17 := addmod(var16, var1, r) + let var18 := mulmod(var15, var17, r) + let a_2 := calldataload(0x0664) + let a_1 := calldataload(0x0644) + let var19 := sub(r, a_1) + let var20 := sub(r, var19) + let var21 := addmod(a_2, var20, r) + let var22 := mulmod(var18, var21, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var22, r) + } + { + let f_13 := calldataload(0x0924) + let var0 := 0x1 + let var1 := sub(r, f_13) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_13, var2, r) + let var4 := 0x2 + let var5 := addmod(var4, var1, r) + let var6 := mulmod(var3, var5, r) + let var7 := 0x3 + let var8 := addmod(var7, var1, r) + let var9 := mulmod(var6, var8, r) + let var10 := 0x4 + let var11 := addmod(var10, var1, r) + let var12 := mulmod(var9, var11, r) + let var13 := 0x5 + let var14 := addmod(var13, var1, r) + let var15 := mulmod(var12, var14, r) + let var16 := 0x6 + let var17 := addmod(var16, var1, r) + let var18 := mulmod(var15, var17, r) + let a_1 := calldataload(0x0644) + let var19 := mulmod(var18, a_1, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var19, r) + } + { + let f_14 := calldataload(0x0944) + let var0 := 0x1 + let var1 := sub(r, f_14) + let var2 := addmod(var0, var1, r) + let var3 := mulmod(f_14, var2, r) + let a_1 := calldataload(0x0644) + let var4 := sub(r, var0) + let var5 := addmod(a_1, var4, r) + let var6 := mulmod(a_1, var5, r) + let var7 := mulmod(var3, var6, r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), var7, r) + } + { + let l_0 := mload(L_0_MPTR) + let eval := addmod(l_0, sub(r, mulmod(l_0, calldataload(0x0aa4), r)), r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), eval, r) + } + { + let perm_z_last := calldataload(0x0b04) + let eval := mulmod(mload(L_LAST_MPTR), addmod(mulmod(perm_z_last, perm_z_last, r), sub(r, perm_z_last), r), r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), eval, r) + } + { + let eval := mulmod(mload(L_0_MPTR), addmod(calldataload(0x0b04), sub(r, calldataload(0x0ae4)), r), r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), eval, r) + } + { + let gamma := mload(GAMMA_MPTR) + let beta := mload(BETA_MPTR) + let lhs := calldataload(0x0ac4) + let rhs := calldataload(0x0aa4) + lhs := mulmod(lhs, addmod(addmod(calldataload(0x0624), mulmod(beta, calldataload(0x0984), r), r), gamma, r), r) + lhs := mulmod(lhs, addmod(addmod(calldataload(0x0644), mulmod(beta, calldataload(0x09a4), r), r), gamma, r), r) + lhs := mulmod(lhs, addmod(addmod(calldataload(0x0664), mulmod(beta, calldataload(0x09c4), r), r), gamma, r), r) + lhs := mulmod(lhs, addmod(addmod(calldataload(0x0784), mulmod(beta, calldataload(0x09e4), r), r), gamma, r), r) + lhs := mulmod(lhs, addmod(addmod(calldataload(0x0684), mulmod(beta, calldataload(0x0a04), r), r), gamma, r), r) + lhs := mulmod(lhs, addmod(addmod(calldataload(0x06a4), mulmod(beta, calldataload(0x0a24), r), r), gamma, r), r) + lhs := mulmod(lhs, addmod(addmod(calldataload(0x07a4), mulmod(beta, calldataload(0x0a44), r), r), gamma, r), r) + mstore(0x00, mulmod(beta, mload(X_MPTR), r)) + rhs := mulmod(rhs, addmod(addmod(calldataload(0x0624), mload(0x00), r), gamma, r), r) + mstore(0x00, mulmod(mload(0x00), delta, r)) + rhs := mulmod(rhs, addmod(addmod(calldataload(0x0644), mload(0x00), r), gamma, r), r) + mstore(0x00, mulmod(mload(0x00), delta, r)) + rhs := mulmod(rhs, addmod(addmod(calldataload(0x0664), mload(0x00), r), gamma, r), r) + mstore(0x00, mulmod(mload(0x00), delta, r)) + rhs := mulmod(rhs, addmod(addmod(calldataload(0x0784), mload(0x00), r), gamma, r), r) + mstore(0x00, mulmod(mload(0x00), delta, r)) + rhs := mulmod(rhs, addmod(addmod(calldataload(0x0684), mload(0x00), r), gamma, r), r) + mstore(0x00, mulmod(mload(0x00), delta, r)) + rhs := mulmod(rhs, addmod(addmod(calldataload(0x06a4), mload(0x00), r), gamma, r), r) + mstore(0x00, mulmod(mload(0x00), delta, r)) + rhs := mulmod(rhs, addmod(addmod(calldataload(0x07a4), mload(0x00), r), gamma, r), r) + mstore(0x00, mulmod(mload(0x00), delta, r)) + let left_sub_right := addmod(lhs, sub(r, rhs), r) + let eval := addmod(left_sub_right, sub(r, mulmod(left_sub_right, addmod(mload(L_LAST_MPTR), mload(L_BLIND_MPTR), r), r)), r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), eval, r) + } + { + let gamma := mload(GAMMA_MPTR) + let beta := mload(BETA_MPTR) + let lhs := calldataload(0x0b24) + let rhs := calldataload(0x0b04) + lhs := mulmod(lhs, addmod(addmod(mload(INSTANCE_EVAL_MPTR), mulmod(beta, calldataload(0x0a64), r), r), gamma, r), r) + lhs := mulmod(lhs, addmod(addmod(calldataload(0x07c4), mulmod(beta, calldataload(0x0a84), r), r), gamma, r), r) + rhs := mulmod(rhs, addmod(addmod(mload(INSTANCE_EVAL_MPTR), mload(0x00), r), gamma, r), r) + mstore(0x00, mulmod(mload(0x00), delta, r)) + rhs := mulmod(rhs, addmod(addmod(calldataload(0x07c4), mload(0x00), r), gamma, r), r) + let left_sub_right := addmod(lhs, sub(r, rhs), r) + let eval := addmod(left_sub_right, sub(r, mulmod(left_sub_right, addmod(mload(L_LAST_MPTR), mload(L_BLIND_MPTR), r), r)), r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), eval, r) + } + { + let l_0 := mload(L_0_MPTR) + let eval := mulmod(l_0, calldataload(0x0b44), r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), eval, r) + } + { + let l_last := mload(L_LAST_MPTR) + let eval := mulmod(l_last, calldataload(0x0b44), r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), eval, r) + } + { + let theta := mload(THETA_MPTR) + let beta := mload(BETA_MPTR) + let table + { + let f_5 := calldataload(0x0824) + let f_6 := calldataload(0x0844) + table := f_5 + table := addmod(mulmod(table, theta, r), f_6, r) + table := addmod(table, beta, r) + } + let input_0 + { + let f_9 := calldataload(0x08a4) + let var0 := 0x1 + let var1 := mulmod(f_9, var0, r) + let a_0 := calldataload(0x0624) + let var2 := mulmod(var1, a_0, r) + let var3 := sub(r, var1) + let var4 := addmod(var0, var3, r) + let var5 := 0x0 + let var6 := mulmod(var4, var5, r) + let var7 := addmod(var2, var6, r) + let a_1 := calldataload(0x0644) + let var8 := mulmod(var1, a_1, r) + let var9 := addmod(var8, var6, r) + input_0 := var7 + input_0 := addmod(mulmod(input_0, theta, r), var9, r) + input_0 := addmod(input_0, beta, r) + } + let lhs + let rhs + rhs := table + { + let tmp := input_0 + rhs := addmod(rhs, sub(r, mulmod(calldataload(0x0b84), tmp, r)), r) + lhs := mulmod(mulmod(table, tmp, r), addmod(calldataload(0x0b64), sub(r, calldataload(0x0b44)), r), r) + } + let eval := mulmod(addmod(1, sub(r, addmod(mload(L_BLIND_MPTR), mload(L_LAST_MPTR), r)), r), addmod(lhs, sub(r, rhs), r), r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), eval, r) + } + { + let l_0 := mload(L_0_MPTR) + let eval := mulmod(l_0, calldataload(0x0ba4), r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), eval, r) + } + { + let l_last := mload(L_LAST_MPTR) + let eval := mulmod(l_last, calldataload(0x0ba4), r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), eval, r) + } + { + let theta := mload(THETA_MPTR) + let beta := mload(BETA_MPTR) + let table + { + let f_5 := calldataload(0x0824) + let f_7 := calldataload(0x0864) + table := f_5 + table := addmod(mulmod(table, theta, r), f_7, r) + table := addmod(table, beta, r) + } + let input_0 + { + let f_10 := calldataload(0x08c4) + let var0 := 0x1 + let var1 := mulmod(f_10, var0, r) + let a_0 := calldataload(0x0624) + let var2 := mulmod(var1, a_0, r) + let var3 := sub(r, var1) + let var4 := addmod(var0, var3, r) + let var5 := 0x0 + let var6 := mulmod(var4, var5, r) + let var7 := addmod(var2, var6, r) + let a_1 := calldataload(0x0644) + let var8 := mulmod(var1, a_1, r) + let var9 := addmod(var8, var6, r) + input_0 := var7 + input_0 := addmod(mulmod(input_0, theta, r), var9, r) + input_0 := addmod(input_0, beta, r) + } + let lhs + let rhs + rhs := table + { + let tmp := input_0 + rhs := addmod(rhs, sub(r, mulmod(calldataload(0x0be4), tmp, r)), r) + lhs := mulmod(mulmod(table, tmp, r), addmod(calldataload(0x0bc4), sub(r, calldataload(0x0ba4)), r), r) + } + let eval := mulmod(addmod(1, sub(r, addmod(mload(L_BLIND_MPTR), mload(L_LAST_MPTR), r)), r), addmod(lhs, sub(r, rhs), r), r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), eval, r) + } + { + let l_0 := mload(L_0_MPTR) + let eval := mulmod(l_0, calldataload(0x0c04), r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), eval, r) + } + { + let l_last := mload(L_LAST_MPTR) + let eval := mulmod(l_last, calldataload(0x0c04), r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), eval, r) + } + { + let theta := mload(THETA_MPTR) + let beta := mload(BETA_MPTR) + let table + { + let f_5 := calldataload(0x0824) + let f_8 := calldataload(0x0884) + table := f_5 + table := addmod(mulmod(table, theta, r), f_8, r) + table := addmod(table, beta, r) + } + let input_0 + { + let f_11 := calldataload(0x08e4) + let var0 := 0x1 + let var1 := mulmod(f_11, var0, r) + let a_0 := calldataload(0x0624) + let var2 := mulmod(var1, a_0, r) + let var3 := sub(r, var1) + let var4 := addmod(var0, var3, r) + let var5 := 0x0 + let var6 := mulmod(var4, var5, r) + let var7 := addmod(var2, var6, r) + let a_1 := calldataload(0x0644) + let var8 := mulmod(var1, a_1, r) + let var9 := mulmod(var4, var0, r) + let var10 := addmod(var8, var9, r) + input_0 := var7 + input_0 := addmod(mulmod(input_0, theta, r), var10, r) + input_0 := addmod(input_0, beta, r) + } + let lhs + let rhs + rhs := table + { + let tmp := input_0 + rhs := addmod(rhs, sub(r, mulmod(calldataload(0x0c44), tmp, r)), r) + lhs := mulmod(mulmod(table, tmp, r), addmod(calldataload(0x0c24), sub(r, calldataload(0x0c04)), r), r) + } + let eval := mulmod(addmod(1, sub(r, addmod(mload(L_BLIND_MPTR), mload(L_LAST_MPTR), r)), r), addmod(lhs, sub(r, rhs), r), r) + quotient_eval_numer := addmod(mulmod(quotient_eval_numer, y, r), eval, r) + } + + pop(y) + pop(delta) + + let quotient_eval := mulmod(quotient_eval_numer, mload(X_N_MINUS_1_INV_MPTR), r) + mstore(QUOTIENT_EVAL_MPTR, quotient_eval) + } + + // Compute quotient commitment + { + mstore(0x00, calldataload(LAST_QUOTIENT_X_CPTR)) + mstore(0x20, calldataload(add(LAST_QUOTIENT_X_CPTR, 0x20))) + let x_n := mload(X_N_MPTR) + for + { + let cptr := sub(LAST_QUOTIENT_X_CPTR, 0x40) + let cptr_end := sub(FIRST_QUOTIENT_X_CPTR, 0x40) + } + lt(cptr_end, cptr) + {} + { + success := ec_mul_acc(success, x_n) + success := ec_add_acc(success, calldataload(cptr), calldataload(add(cptr, 0x20))) + cptr := sub(cptr, 0x40) + } + mstore(QUOTIENT_X_MPTR, mload(0x00)) + mstore(QUOTIENT_Y_MPTR, mload(0x20)) + } + + // Compute pairing lhs and rhs + { + { + let x := mload(X_MPTR) + let omega := mload(OMEGA_MPTR) + let omega_inv := mload(OMEGA_INV_MPTR) + let x_pow_of_omega := mulmod(x, omega, r) + mstore(0x0420, x_pow_of_omega) + mstore(0x0400, x) + x_pow_of_omega := mulmod(x, omega_inv, r) + mstore(0x03e0, x_pow_of_omega) + x_pow_of_omega := mulmod(x_pow_of_omega, omega_inv, r) + x_pow_of_omega := mulmod(x_pow_of_omega, omega_inv, r) + x_pow_of_omega := mulmod(x_pow_of_omega, omega_inv, r) + x_pow_of_omega := mulmod(x_pow_of_omega, omega_inv, r) + x_pow_of_omega := mulmod(x_pow_of_omega, omega_inv, r) + mstore(0x03c0, x_pow_of_omega) + } + { + let mu := mload(MU_MPTR) + for + { + let mptr := 0x0440 + let mptr_end := 0x04c0 + let point_mptr := 0x03c0 + } + lt(mptr, mptr_end) + { + mptr := add(mptr, 0x20) + point_mptr := add(point_mptr, 0x20) + } + { + mstore(mptr, addmod(mu, sub(r, mload(point_mptr)), r)) + } + let s + s := mload(0x0480) + mstore(0x04c0, s) + let diff + diff := mload(0x0440) + diff := mulmod(diff, mload(0x0460), r) + diff := mulmod(diff, mload(0x04a0), r) + mstore(0x04e0, diff) + mstore(0x00, diff) + diff := mload(0x0440) + diff := mulmod(diff, mload(0x04a0), r) + mstore(0x0500, diff) + diff := mload(0x0440) + mstore(0x0520, diff) + diff := mload(0x0460) + mstore(0x0540, diff) + diff := mload(0x0440) + diff := mulmod(diff, mload(0x0460), r) + mstore(0x0560, diff) + } + { + let point_2 := mload(0x0400) + let coeff + coeff := 1 + coeff := mulmod(coeff, mload(0x0480), r) + mstore(0x20, coeff) + } + { + let point_1 := mload(0x03e0) + let point_2 := mload(0x0400) + let coeff + coeff := addmod(point_1, sub(r, point_2), r) + coeff := mulmod(coeff, mload(0x0460), r) + mstore(0x40, coeff) + coeff := addmod(point_2, sub(r, point_1), r) + coeff := mulmod(coeff, mload(0x0480), r) + mstore(0x60, coeff) + } + { + let point_1 := mload(0x03e0) + let point_2 := mload(0x0400) + let point_3 := mload(0x0420) + let coeff + coeff := addmod(point_1, sub(r, point_2), r) + coeff := mulmod(coeff, addmod(point_1, sub(r, point_3), r), r) + coeff := mulmod(coeff, mload(0x0460), r) + mstore(0x80, coeff) + coeff := addmod(point_2, sub(r, point_1), r) + coeff := mulmod(coeff, addmod(point_2, sub(r, point_3), r), r) + coeff := mulmod(coeff, mload(0x0480), r) + mstore(0xa0, coeff) + coeff := addmod(point_3, sub(r, point_1), r) + coeff := mulmod(coeff, addmod(point_3, sub(r, point_2), r), r) + coeff := mulmod(coeff, mload(0x04a0), r) + mstore(0xc0, coeff) + } + { + let point_0 := mload(0x03c0) + let point_2 := mload(0x0400) + let point_3 := mload(0x0420) + let coeff + coeff := addmod(point_0, sub(r, point_2), r) + coeff := mulmod(coeff, addmod(point_0, sub(r, point_3), r), r) + coeff := mulmod(coeff, mload(0x0440), r) + mstore(0xe0, coeff) + coeff := addmod(point_2, sub(r, point_0), r) + coeff := mulmod(coeff, addmod(point_2, sub(r, point_3), r), r) + coeff := mulmod(coeff, mload(0x0480), r) + mstore(0x0100, coeff) + coeff := addmod(point_3, sub(r, point_0), r) + coeff := mulmod(coeff, addmod(point_3, sub(r, point_2), r), r) + coeff := mulmod(coeff, mload(0x04a0), r) + mstore(0x0120, coeff) + } + { + let point_2 := mload(0x0400) + let point_3 := mload(0x0420) + let coeff + coeff := addmod(point_2, sub(r, point_3), r) + coeff := mulmod(coeff, mload(0x0480), r) + mstore(0x0140, coeff) + coeff := addmod(point_3, sub(r, point_2), r) + coeff := mulmod(coeff, mload(0x04a0), r) + mstore(0x0160, coeff) + } + { + success := batch_invert(success, 0, 0x0180, r) + let diff_0_inv := mload(0x00) + mstore(0x04e0, diff_0_inv) + for + { + let mptr := 0x0500 + let mptr_end := 0x0580 + } + lt(mptr, mptr_end) + { mptr := add(mptr, 0x20) } + { + mstore(mptr, mulmod(mload(mptr), diff_0_inv, r)) + } + } + { + let coeff := mload(0x20) + let zeta := mload(ZETA_MPTR) + let r_eval := 0 + r_eval := addmod(r_eval, mulmod(coeff, calldataload(0x0964), r), r) + r_eval := mulmod(r_eval, zeta, r) + r_eval := addmod(r_eval, mulmod(coeff, mload(QUOTIENT_EVAL_MPTR), r), r) + for + { + let mptr := 0x0a84 + let mptr_end := 0x0964 + } + lt(mptr_end, mptr) + { mptr := sub(mptr, 0x20) } + { + r_eval := addmod(mulmod(r_eval, zeta, r), mulmod(coeff, calldataload(mptr), r), r) + } + for + { + let mptr := 0x0944 + let mptr_end := 0x0764 + } + lt(mptr_end, mptr) + { mptr := sub(mptr, 0x20) } + { + r_eval := addmod(mulmod(r_eval, zeta, r), mulmod(coeff, calldataload(mptr), r), r) + } + r_eval := mulmod(r_eval, zeta, r) + r_eval := addmod(r_eval, mulmod(coeff, calldataload(0x0c44), r), r) + r_eval := mulmod(r_eval, zeta, r) + r_eval := addmod(r_eval, mulmod(coeff, calldataload(0x0be4), r), r) + r_eval := mulmod(r_eval, zeta, r) + r_eval := addmod(r_eval, mulmod(coeff, calldataload(0x0b84), r), r) + r_eval := mulmod(r_eval, zeta, r) + r_eval := addmod(r_eval, mulmod(coeff, calldataload(0x0704), r), r) + r_eval := mulmod(r_eval, zeta, r) + r_eval := addmod(r_eval, mulmod(coeff, calldataload(0x0644), r), r) + r_eval := mulmod(r_eval, zeta, r) + r_eval := addmod(r_eval, mulmod(coeff, calldataload(0x0624), r), r) + mstore(0x0580, r_eval) + } + { + let zeta := mload(ZETA_MPTR) + let r_eval := 0 + r_eval := addmod(r_eval, mulmod(mload(0x40), calldataload(0x0764), r), r) + r_eval := addmod(r_eval, mulmod(mload(0x60), calldataload(0x0664), r), r) + r_eval := mulmod(r_eval, mload(0x0500), r) + mstore(0x05a0, r_eval) + } + { + let zeta := mload(ZETA_MPTR) + let r_eval := 0 + r_eval := addmod(r_eval, mulmod(mload(0x80), calldataload(0x0724), r), r) + r_eval := addmod(r_eval, mulmod(mload(0xa0), calldataload(0x06a4), r), r) + r_eval := addmod(r_eval, mulmod(mload(0xc0), calldataload(0x06e4), r), r) + r_eval := mulmod(r_eval, zeta, r) + r_eval := addmod(r_eval, mulmod(mload(0x80), calldataload(0x0744), r), r) + r_eval := addmod(r_eval, mulmod(mload(0xa0), calldataload(0x0684), r), r) + r_eval := addmod(r_eval, mulmod(mload(0xc0), calldataload(0x06c4), r), r) + r_eval := mulmod(r_eval, mload(0x0520), r) + mstore(0x05c0, r_eval) + } + { + let zeta := mload(ZETA_MPTR) + let r_eval := 0 + r_eval := addmod(r_eval, mulmod(mload(0xe0), calldataload(0x0ae4), r), r) + r_eval := addmod(r_eval, mulmod(mload(0x0100), calldataload(0x0aa4), r), r) + r_eval := addmod(r_eval, mulmod(mload(0x0120), calldataload(0x0ac4), r), r) + r_eval := mulmod(r_eval, mload(0x0540), r) + mstore(0x05e0, r_eval) + } + { + let zeta := mload(ZETA_MPTR) + let r_eval := 0 + r_eval := addmod(r_eval, mulmod(mload(0x0140), calldataload(0x0c04), r), r) + r_eval := addmod(r_eval, mulmod(mload(0x0160), calldataload(0x0c24), r), r) + r_eval := mulmod(r_eval, zeta, r) + r_eval := addmod(r_eval, mulmod(mload(0x0140), calldataload(0x0ba4), r), r) + r_eval := addmod(r_eval, mulmod(mload(0x0160), calldataload(0x0bc4), r), r) + r_eval := mulmod(r_eval, zeta, r) + r_eval := addmod(r_eval, mulmod(mload(0x0140), calldataload(0x0b44), r), r) + r_eval := addmod(r_eval, mulmod(mload(0x0160), calldataload(0x0b64), r), r) + r_eval := mulmod(r_eval, zeta, r) + r_eval := addmod(r_eval, mulmod(mload(0x0140), calldataload(0x0b04), r), r) + r_eval := addmod(r_eval, mulmod(mload(0x0160), calldataload(0x0b24), r), r) + r_eval := mulmod(r_eval, mload(0x0560), r) + mstore(0x0600, r_eval) + } + { + let sum := mload(0x20) + mstore(0x0620, sum) + } + { + let sum := mload(0x40) + sum := addmod(sum, mload(0x60), r) + mstore(0x0640, sum) + } + { + let sum := mload(0x80) + sum := addmod(sum, mload(0xa0), r) + sum := addmod(sum, mload(0xc0), r) + mstore(0x0660, sum) + } + { + let sum := mload(0xe0) + sum := addmod(sum, mload(0x0100), r) + sum := addmod(sum, mload(0x0120), r) + mstore(0x0680, sum) + } + { + let sum := mload(0x0140) + sum := addmod(sum, mload(0x0160), r) + mstore(0x06a0, sum) + } + { + for + { + let mptr := 0x00 + let mptr_end := 0xa0 + let sum_mptr := 0x0620 + } + lt(mptr, mptr_end) + { + mptr := add(mptr, 0x20) + sum_mptr := add(sum_mptr, 0x20) + } + { + mstore(mptr, mload(sum_mptr)) + } + success := batch_invert(success, 0, 0xa0, r) + let r_eval := mulmod(mload(0x80), mload(0x0600), r) + for + { + let sum_inv_mptr := 0x60 + let sum_inv_mptr_end := 0xa0 + let r_eval_mptr := 0x05e0 + } + lt(sum_inv_mptr, sum_inv_mptr_end) + { + sum_inv_mptr := sub(sum_inv_mptr, 0x20) + r_eval_mptr := sub(r_eval_mptr, 0x20) + } + { + r_eval := mulmod(r_eval, mload(NU_MPTR), r) + r_eval := addmod(r_eval, mulmod(mload(sum_inv_mptr), mload(r_eval_mptr), r), r) + } + mstore(R_EVAL_MPTR, r_eval) + } + { + let nu := mload(NU_MPTR) + mstore(0x00, calldataload(0x03e4)) + mstore(0x20, calldataload(0x0404)) + success := ec_mul_acc(success, mload(ZETA_MPTR)) + success := ec_add_acc(success, mload(QUOTIENT_X_MPTR), mload(QUOTIENT_Y_MPTR)) + for + { + let mptr := 0x0f20 + let mptr_end := 0x0a60 + } + lt(mptr_end, mptr) + { mptr := sub(mptr, 0x40) } + { + success := ec_mul_acc(success, mload(ZETA_MPTR)) + success := ec_add_acc(success, mload(mptr), mload(add(mptr, 0x20))) + } + success := ec_mul_acc(success, mload(ZETA_MPTR)) + success := ec_add_acc(success, mload(0x09e0), mload(0x0a00)) + success := ec_mul_acc(success, mload(ZETA_MPTR)) + success := ec_add_acc(success, mload(0x09a0), mload(0x09c0)) + success := ec_mul_acc(success, mload(ZETA_MPTR)) + success := ec_add_acc(success, mload(0x0a60), mload(0x0a80)) + success := ec_mul_acc(success, mload(ZETA_MPTR)) + success := ec_add_acc(success, mload(0x0a20), mload(0x0a40)) + success := ec_mul_acc(success, mload(ZETA_MPTR)) + success := ec_add_acc(success, mload(0x0960), mload(0x0980)) + for + { + let mptr := 0x0264 + let mptr_end := 0x0164 + } + lt(mptr_end, mptr) + { mptr := sub(mptr, 0x40) } + { + success := ec_mul_acc(success, mload(ZETA_MPTR)) + success := ec_add_acc(success, calldataload(mptr), calldataload(add(mptr, 0x20))) + } + success := ec_mul_acc(success, mload(ZETA_MPTR)) + success := ec_add_acc(success, calldataload(0xa4), calldataload(0xc4)) + success := ec_mul_acc(success, mload(ZETA_MPTR)) + success := ec_add_acc(success, calldataload(0x64), calldataload(0x84)) + mstore(0x80, calldataload(0xe4)) + mstore(0xa0, calldataload(0x0104)) + success := ec_mul_tmp(success, mulmod(nu, mload(0x0500), r)) + success := ec_add_acc(success, mload(0x80), mload(0xa0)) + nu := mulmod(nu, mload(NU_MPTR), r) + mstore(0x80, calldataload(0x0164)) + mstore(0xa0, calldataload(0x0184)) + success := ec_mul_tmp(success, mload(ZETA_MPTR)) + success := ec_add_tmp(success, calldataload(0x0124), calldataload(0x0144)) + success := ec_mul_tmp(success, mulmod(nu, mload(0x0520), r)) + success := ec_add_acc(success, mload(0x80), mload(0xa0)) + nu := mulmod(nu, mload(NU_MPTR), r) + mstore(0x80, calldataload(0x02a4)) + mstore(0xa0, calldataload(0x02c4)) + success := ec_mul_tmp(success, mulmod(nu, mload(0x0540), r)) + success := ec_add_acc(success, mload(0x80), mload(0xa0)) + nu := mulmod(nu, mload(NU_MPTR), r) + mstore(0x80, calldataload(0x03a4)) + mstore(0xa0, calldataload(0x03c4)) + for + { + let mptr := 0x0364 + let mptr_end := 0x02a4 + } + lt(mptr_end, mptr) + { mptr := sub(mptr, 0x40) } + { + success := ec_mul_tmp(success, mload(ZETA_MPTR)) + success := ec_add_tmp(success, calldataload(mptr), calldataload(add(mptr, 0x20))) + } + success := ec_mul_tmp(success, mulmod(nu, mload(0x0560), r)) + success := ec_add_acc(success, mload(0x80), mload(0xa0)) + mstore(0x80, mload(G1_X_MPTR)) + mstore(0xa0, mload(G1_Y_MPTR)) + success := ec_mul_tmp(success, sub(r, mload(R_EVAL_MPTR))) + success := ec_add_acc(success, mload(0x80), mload(0xa0)) + mstore(0x80, calldataload(0x0c64)) + mstore(0xa0, calldataload(0x0c84)) + success := ec_mul_tmp(success, sub(r, mload(0x04c0))) + success := ec_add_acc(success, mload(0x80), mload(0xa0)) + mstore(0x80, calldataload(0x0ca4)) + mstore(0xa0, calldataload(0x0cc4)) + success := ec_mul_tmp(success, mload(MU_MPTR)) + success := ec_add_acc(success, mload(0x80), mload(0xa0)) + mstore(PAIRING_LHS_X_MPTR, mload(0x00)) + mstore(PAIRING_LHS_Y_MPTR, mload(0x20)) + mstore(PAIRING_RHS_X_MPTR, calldataload(0x0ca4)) + mstore(PAIRING_RHS_Y_MPTR, calldataload(0x0cc4)) + } + } + + // Random linear combine with accumulator + if mload(HAS_ACCUMULATOR_MPTR) { + mstore(0x00, mload(ACC_LHS_X_MPTR)) + mstore(0x20, mload(ACC_LHS_Y_MPTR)) + mstore(0x40, mload(ACC_RHS_X_MPTR)) + mstore(0x60, mload(ACC_RHS_Y_MPTR)) + mstore(0x80, mload(PAIRING_LHS_X_MPTR)) + mstore(0xa0, mload(PAIRING_LHS_Y_MPTR)) + mstore(0xc0, mload(PAIRING_RHS_X_MPTR)) + mstore(0xe0, mload(PAIRING_RHS_Y_MPTR)) + let challenge := mod(keccak256(0x00, 0x100), r) + + // [pairing_lhs] += challenge * [acc_lhs] + success := ec_mul_acc(success, challenge) + success := ec_add_acc(success, mload(PAIRING_LHS_X_MPTR), mload(PAIRING_LHS_Y_MPTR)) + mstore(PAIRING_LHS_X_MPTR, mload(0x00)) + mstore(PAIRING_LHS_Y_MPTR, mload(0x20)) + + // [pairing_rhs] += challenge * [acc_rhs] + mstore(0x00, mload(ACC_RHS_X_MPTR)) + mstore(0x20, mload(ACC_RHS_Y_MPTR)) + success := ec_mul_acc(success, challenge) + success := ec_add_acc(success, mload(PAIRING_RHS_X_MPTR), mload(PAIRING_RHS_Y_MPTR)) + mstore(PAIRING_RHS_X_MPTR, mload(0x00)) + mstore(PAIRING_RHS_Y_MPTR, mload(0x20)) + } + + // Perform pairing + success := ec_pairing( + success, + mload(PAIRING_LHS_X_MPTR), + mload(PAIRING_LHS_Y_MPTR), + mload(PAIRING_RHS_X_MPTR), + mload(PAIRING_RHS_Y_MPTR) + ) + + // Revert if anything fails + if iszero(success) { + revert(0x00, 0x00) + } + + // Return 1 as result if everything succeeds + mstore(0x00, 1) + return(0x00, 0x20) + } + } +} diff --git a/foundry.toml b/foundry.toml new file mode 100644 index 0000000..0f88bd4 --- /dev/null +++ b/foundry.toml @@ -0,0 +1,19 @@ +# Binding solc to <0.8.20 because of bug in 0.8.21 +# https://github.com/foundry-rs/foundry/issues/5762 +# https://github.com/ethereum/solidity/issues/14430 + +# Further binding to 0.8.19 because Base has not +# executed Shanghai upgrade and safer to keep binded + +[profile.default] +src = "src" +out = "out" +libs = ["lib"] +solc-version = "0.8.19" +optimizer_runs = 1000000 +evm_version = "paris" +via_ir = true + +[fmt] +number_underscore = "thousands" +single_line_statement_blocks = "multi" diff --git a/lib/forge-std b/lib/forge-std new file mode 160000 index 0000000..2f11269 --- /dev/null +++ b/lib/forge-std @@ -0,0 +1 @@ +Subproject commit 2f112697506eab12d433a65fdc31a639548fe365 diff --git a/lib/solady b/lib/solady new file mode 160000 index 0000000..fad3f67 --- /dev/null +++ b/lib/solady @@ -0,0 +1 @@ +Subproject commit fad3f6703c2cd4cfd185f9921790d117503f54c6 diff --git a/remappings.txt b/remappings.txt new file mode 100644 index 0000000..183f9e1 --- /dev/null +++ b/remappings.txt @@ -0,0 +1,2 @@ +solady/=lib/solady/src +forge-std/=lib/forge-std/src diff --git a/scripts/Deploy.sol b/scripts/Deploy.sol new file mode 100644 index 0000000..f3d0a14 --- /dev/null +++ b/scripts/Deploy.sol @@ -0,0 +1,27 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {Script} from "forge-std/Script.sol"; +import {console} from "forge-std/console.sol"; +import {EIP712Coordinator} from "../src/EIP712Coordinator.sol"; + +/// @title Deploy +/// @notice Deploys EIP712Coordinator to destination chain defined in environment +contract Deploy is Script { + function run() public { + // Setup wallet + uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY"); + vm.startBroadcast(deployerPrivateKey); + + // Log address + address deployerAddress = vm.addr(deployerPrivateKey); + console.log("Loaded deployer: ", deployerAddress); + + // Create Coordinator + EIP712Coordinator coordinator = new EIP712Coordinator(); + console.log("Deployed EIP712Coordinator: ", address(coordinator)); + + // Execute + vm.stopBroadcast(); + } +} diff --git a/src/Coordinator.sol b/src/Coordinator.sol new file mode 100644 index 0000000..da1a0c4 --- /dev/null +++ b/src/Coordinator.sol @@ -0,0 +1,435 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {Manager} from "./Manager.sol"; +import {BaseConsumer} from "./consumer/Base.sol"; + +/// @title Coordinator +/// @notice Coordination layer between consuming smart contracts and off-chain Infernet nodes +/// @dev Allows creating and deleting `Subscription`(s) +/// @dev Allows nodes with `Manager.NodeStatus.Active` to deliver subscription outputs via off-chain container compute +contract Coordinator is Manager { + /*////////////////////////////////////////////////////////////// + STRUCTS + //////////////////////////////////////////////////////////////*/ + + /// @notice A subscription is the fundamental unit of Infernet + /// @dev A subscription represents some request configuration for off-chain compute via containers on Infernet nodes + /// @dev A subscription with `frequency == 1` is a one-time subscription (a callback) + /// @dev A subscription with `frequency > 1` is a recurring subscription (many callbacks) + /// @dev Tightly-packed struct: + /// - [owner, activeAt, period, frequency]: [32, 160, 32, 32] = 256 + /// - [redundancy, maxGasPrice, maxGasLimit]: [16, 48, 32] = 96 + struct Subscription { + /// @notice Subscription owner + recipient + /// @dev This is the address called to fulfill a subscription request and must inherit `BaseConsumer` + /// @dev Default initializes to `address(0)` + address owner; + /// @notice Timestamp when subscription is first active and an off-chain Infernet node can respond + /// @dev When `period == 0`, the subscription is immediately active + /// @dev When `period > 0`, subscription is active at `createdAt + period` + uint32 activeAt; + /// @notice Time, in seconds, between each subscription interval + /// @dev At worst, assuming subscription occurs once/year << uint32 + uint32 period; + /// @notice Number of times a subscription is processed + /// @dev At worst, assuming 30 req/min * 60 min * 24 hours * 365 days * 10 years << uint32 + uint32 frequency; + /// @notice Number of unique nodes that can fulfill a subscription at each `interval` + /// @dev uint16 allows for >255 nodes (uint8) but <65,535 + uint16 redundancy; + /// @notice Max gas price in wei paid by an Infernet node when fulfilling callback + /// @dev uint40 caps out at ~1099 gwei, uint48 allows up to ~281K gwei + uint48 maxGasPrice; + /// @notice Max gas limit in wei used by an Infernet node when fulfilling callback + /// @dev Must be at least equal to the gas limit of your receiving function execution + DELIVERY_OVERHEAD_WEI + /// @dev uint24 is too small at ~16.7M (<30M mainnet gas limit), but uint32 is more than enough (~4.2B wei) + uint32 maxGasLimit; + /// @notice Container identifier used by off-chain Infernet nodes to determine which container is used to fulfill a subscription + /// @dev Can be used to specify a linear DAG of containers by seperating container names with a "," delimiter ("A,B,C") + /// @dev Better represented by a string[] type but constrained to string to keep struct and functions simple + string containerId; + /// @notice Optional container input parameters + /// @dev If left empty, off-chain Infernet nodes call public view fn: `BaseConsumer(owner).getContainerInputs()` + bytes inputs; + } + + /*////////////////////////////////////////////////////////////// + CONSTANTS + //////////////////////////////////////////////////////////////*/ + + /// @notice Gas overhead in wei to deliver container compute responses + /// @dev This is the additional cost of any validation checks performed within the `Coordinator` + /// before delivering responses to consumer contracts + /// @dev A uint16 is sufficient but we are not packing variables so control plane cost is higher because of type + /// casting during operations. Thus, we can just stick to uint256 + uint256 public constant DELIVERY_OVERHEAD_WEI = 56_600 wei; + + /*////////////////////////////////////////////////////////////// + MUTABLE + //////////////////////////////////////////////////////////////*/ + + /// @notice Current highest subscription ID + /// @dev 1-indexed to allow using id as a mapping value (prevent 0-indexed default from being misused) + /// @dev uint32 size(4.2B) should be sufficiently large + uint32 public id = 1; + + /// @notice hash(subscriptionId, interval, caller) => has caller responded for (sub, interval)? + mapping(bytes32 => bool) public nodeResponded; + + /// @notice hash(subscriptionId, interval) => Number of responses for (sub, interval)? + /// @dev Limited to type(Subscription.redundancy) == uint16 + /// @dev Technically, this is not required and we can save an SLOAD if we simply add a uint48 to the subscription + /// struct that represents 32 bits of the interval -> 16 bits of redundancy count, reset each interval change + /// But, this is a little over the optimization:redability line and would make Subscriptions harder to grok + mapping(bytes32 => uint16) public redundancyCount; + + /// @notice subscriptionID => Subscription + /// @dev 1-indexed, 0th-subscription is empty + mapping(uint32 => Subscription) public subscriptions; + + /*////////////////////////////////////////////////////////////// + EVENTS + //////////////////////////////////////////////////////////////*/ + + /// @notice Emitted when a new subscription is created + /// @param id subscription ID + event SubscriptionCreated(uint32 indexed id); + + /// @notice Emitted when a subscription is cancelled + /// @param id subscription ID + event SubscriptionCancelled(uint32 indexed id); + + /// @notice Emitted when a subscription is fulfilled + /// @param id subscription ID + /// @param node address of fulfilling node + event SubscriptionFulfilled(uint32 indexed id, address indexed node); + + /*////////////////////////////////////////////////////////////// + ERRORS + //////////////////////////////////////////////////////////////*/ + + /// @notice Thrown by `deliverComputeWithOverhead()` if delivering tx with gasPrice > subscription maxGasPrice + /// @dev E.g. submitting tx with gas price `10 gwei` when network basefee is `11 gwei` + /// @dev 4-byte signature: `0x682bad5a` + error GasPriceExceeded(); + + /// @notice Thrown by `deliverComputeWithOverhead()` if delivering tx with consumed gas > subscription maxGasLimit + /// @dev E.g. submitting tx with gas consumed `200_000 wei` when max allowed by subscription is `175_000 wei` + /// @dev 4-byte signature: `0xbe9179a6` + error GasLimitExceeded(); + + /// @notice Thrown by `deliverComputeWithOverhead()` if attempting to deliver container compute response for non-current interval + /// @dev E.g submitting tx for `interval` < current (period elapsed) or `interval` > current (too early to submit) + /// @dev 4-byte signature: `0x4db310c3` + error IntervalMismatch(); + + /// @notice Thrown by `deliverComputeWithOverhead()` if `redundancy` has been met for current `interval` + /// @dev E.g submitting 4th output tx for a subscription with `redundancy == 3` + /// @dev 4-byte signature: `0x2f4ca85b` + error IntervalCompleted(); + + /// @notice Thrown by `deliverComputeWithOverhead()` if `node` has already responded this `interval` + /// @dev 4-byte signature: `0x88a21e4f` + error NodeRespondedAlready(); + + /// @notice Thrown by `deliverComputeWithOverhead()` if attempting to access a subscription that does not exist + /// @dev 4-byte signature: `0x1a00354f` + error SubscriptionNotFound(); + + /// @notice Thrown by `cancelSubscription()` if attempting to modify a subscription not owned by caller + /// @dev 4-byte signature: `0xa7fba711` + error NotSubscriptionOwner(); + + /// @notice Thrown by `deliverComputeWithOverhead()` if attempting to deliver a completed subscription + /// @dev 4-byte signature: `0xae6704a7` + error SubscriptionCompleted(); + + /// @notice Thrown by `deliverComputeWithOverhead()` if attempting to deliver a subscription before `activeAt` + /// @dev 4-byte signature: `0xefb74efe` + error SubscriptionNotActive(); + + /*////////////////////////////////////////////////////////////// + INTERNAL FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Internal counterpart to `deliverCompute()` w/ ability to set custom gas overhead allowance + /// @dev When called by `deliverCompute()`, `callingOverheadWei == 0` because no additional overhead imposed + /// @dev When called by `deliverComputeDelegatee()`, `DELEGATEE_OVERHEAD_*_WEI` is imposed + /// @param subscriptionId subscription ID to deliver + /// @param deliveryInterval subscription `interval` to deliver + /// @param input optional off-chain input recorded by Infernet node (empty, hashed input, processed input, or both) + /// @param output optional off-chain container output (empty, hashed output, processed output, both, or fallback: all encodeable data) + /// @param proof optional container execution proof (or arbitrary metadata) + /// @param callingOverheadWei additional overhead gas used for delivery + function _deliverComputeWithOverhead( + uint32 subscriptionId, + uint32 deliveryInterval, + bytes calldata input, + bytes calldata output, + bytes calldata proof, + uint256 callingOverheadWei + ) internal { + // Naively, one would think that loading a subscription into memory via + // `Subscription memory subscription = subscriptions[subscriptionId]` + // would be cost-effective and most readable. + + // Unfortunately, this is not the case. This function makes no use of + // `subscription.containerId` or `subscription.inputs`. Because these + // are dynamic types, we are forced to pay to load into memory the length + // + content of these parameters. In some cases (say, container input being + // 100 uint256's), we are forced to pay 2 SLOAD (length slot containerId, inputs) + // + N SLOAD (containerId + inputs byte length / word size) (for example, 100 + // SLOAD's in the case of 100 uint256's) + N MSTORE (copying into memory) + // + memory expansion costs. + + // To avoid this, we can first access memory parameters selectively, copying + // just the fixed size params (uint16, etc.) into memory by accessing state via + // `subscriptions[subscriptionId].activeAt` syntax. + + // But, with this syntax, while we avoid the significant overhead of copying + // from storage, into memory, the unnecessary dynamic parameters, we are now + // forced to pay 100 gas for each non-first storage slot read (hot SLOAD). + + // For example, even if accessing two tightly-packed variables in slot 0, we must + // pay COLD SLOAD + HOT SLOAD, rather than just COLD SLOAD + MLOAD. + + // To avoid this, we can drop down to assembly and: + // 1. Manually SLOAD tightly-packed struct slots + // 2. Unpack and MSTORE variables to avoid the hot SLOAD penalty since we + // only copy from storage into memory once (rather than for each variable) + + // Setup parameters in first slot + // Note, we could load these variables right before they are used but the MSTORE is cheap and this is cleaner + address subOwner; + uint32 subActiveAt; + uint32 subPeriod; + uint32 subFrequency; + + // Store slot identifier for subscriptions[subscriptionId][slot 0] + bytes32 storageSlot; + assembly ("memory-safe") { + // Load address of free-memory pointer + let m := mload(0x40) + + // Store subscription ID to first free slot + // uint32 automatically consumes full word + mstore(m, subscriptionId) + // Store subscriptions mapping storage slot (4) to 32 byte (1 word) offset + mstore(add(m, 0x20), 4) + + // At this point, memory layout [0 -> 0x20 == subscriptionId, 0x20 -> 0x40 == 4] + // Calculate mapping storage slot — hash(key, mapping slot) + // Hash data from 0 -> 0x40 (2 words) + storageSlot := keccak256(m, 0x40) + + // SLOAD struct data + let data := sload(storageSlot) + + // Solidity packs structs right to left (least-significant bits a la little-endian) + // MSTORE'ing tightly-packed variables from storage slot data + // Erase first 96 bits via AND, grab last 160 + subOwner := and(data, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) + // Grab first 32 bits preceeding owner + subActiveAt := and(shr(160, data), 0xFFFFFFFF) + // Grab first 32 bits preceeding activeAt + subPeriod := and(shr(192, data), 0xFFFFFFFF) + // Grab first 32 bits from left + subFrequency := shr(224, data) + } + + // Revert if subscription does not exist + if (subOwner == address(0)) { + revert SubscriptionNotFound(); + } + + // Revert if subscription is not yet active + if (block.timestamp < subActiveAt) { + revert SubscriptionNotActive(); + } + + // Calculate subscription interval + uint32 interval = getSubscriptionInterval(subActiveAt, subPeriod); + + // Revert if not processing curent interval + if (interval != deliveryInterval) { + revert IntervalMismatch(); + } + + // Revert if interval > frequency + if (interval > subFrequency) { + revert SubscriptionCompleted(); + } + + // Setup parameters in second slot + uint16 subRedundancy; + uint48 subMaxGasPrice; + uint32 subMaxGasLimit; + + assembly ("memory-safe") { + // SLOAD struct data + // Second slot is simply offset from first by 1 + let data := sload(add(storageSlot, 1)) + + // MSTORE'ing tightly-packed variables from storage slot data + // Grab last 16 bits + subRedundancy := and(data, 0xFFFF) + // Grab first 48 bits preceeding redundancy + subMaxGasPrice := and(shr(16, data), 0xFFFFFFFFFFFF) + // Grab first 32 bits from left + subMaxGasLimit := and(shr(64, data), 0xFFFFFFFF) + } + + // Revert if tx gas price > max subscription allowed + if (tx.gasprice > subMaxGasPrice) { + revert GasPriceExceeded(); + } + + // Revert if redundancy requirements for this interval have been met + bytes32 key = keccak256(abi.encode(subscriptionId, interval)); + uint16 numRedundantDeliveries = redundancyCount[key]; + if (numRedundantDeliveries == subRedundancy) { + revert IntervalCompleted(); + } + // Highly unlikely to overflow given incrementing by 1/node + unchecked { + redundancyCount[key] = numRedundantDeliveries + 1; + } + + // Revert if node has already responded this interval + key = keccak256(abi.encode(subscriptionId, interval, msg.sender)); + if (nodeResponded[key]) { + revert NodeRespondedAlready(); + } + nodeResponded[key] = true; + + // Deliver container compute output to contract (measuring execution cost) + uint256 startingGas = gasleft(); + BaseConsumer(subOwner).rawReceiveCompute( + subscriptionId, interval, numRedundantDeliveries + 1, msg.sender, input, output, proof + ); + uint256 endingGas = gasleft(); + + // Revert if gas used > allowed, we can make unchecked: + // Gas limit in most networks is usually much below uint256 max, and by this point a decent amount is spent + // `callingOverheadWei`, `DELIVERY_OVERHEAD_WEI` both fit in under uint24's + // Thus, this operation is unlikely to ever overflow ((uint256 - uint256) + (uint16 + uint24)) + // Unless the bounds are along the lines of: {startingGas: UINT256_MAX, endingGas: << (callingOverheadWei + DELIVERY_OVERHEAD_WEI)} + uint256 executionCost; + unchecked { + executionCost = startingGas - endingGas + callingOverheadWei + DELIVERY_OVERHEAD_WEI; + } + if (executionCost > subMaxGasLimit) { + revert GasLimitExceeded(); + } + + // Emit successful delivery + emit SubscriptionFulfilled(subscriptionId, msg.sender); + } + + /*////////////////////////////////////////////////////////////// + FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Creates new subscription + /// @param containerId compute container identifier used by off-chain Infernet node + /// @param inputs optional container inputs + /// @param maxGasPrice max gas price in wei paid by an Infernet node when fulfilling callback + /// @param maxGasLimit max gas limit in wei paid by an Infernet node in callback tx + /// @param frequency max number of times to process subscription (i.e, `frequency == 1` is a one-time request) + /// @param period period, in seconds, at which to progress each responding `interval` + /// @param redundancy number of unique responding Infernet nodes + /// @return subscription ID + function createSubscription( + string memory containerId, + bytes calldata inputs, + uint48 maxGasPrice, + uint32 maxGasLimit, + uint32 frequency, + uint32 period, + uint16 redundancy + ) external returns (uint32) { + // Get subscription id and increment + // Unlikely this will ever overflow so we can toss in unchecked + uint32 subscriptionId; + unchecked { + subscriptionId = id++; + } + + // Store new subscription + subscriptions[subscriptionId] = Subscription({ + // If period is = 0 (one-time), active immediately + // Else, next active at first period mark + // Probably reasonable to keep the overflow protection here given adding 2 uint32's into a uint32 + activeAt: uint32(block.timestamp) + period, + owner: msg.sender, + maxGasPrice: maxGasPrice, + redundancy: redundancy, + maxGasLimit: maxGasLimit, + frequency: frequency, + period: period, + containerId: containerId, + inputs: inputs + }); + + // Emit new subscription + emit SubscriptionCreated(subscriptionId); + + // Explicitly return subscriptionId + return subscriptionId; + } + + /// @notice Cancel a subscription + /// @dev Must be called by `subscriptions[subscriptionId].owner` + /// @param subscriptionId subscription ID to cancel + function cancelSubscription(uint32 subscriptionId) external { + // Throw if owner of subscription is not caller + if (subscriptions[subscriptionId].owner != msg.sender) { + revert NotSubscriptionOwner(); + } + + // Nullify subscription + delete subscriptions[subscriptionId]; + + // Emit cancellation + emit SubscriptionCancelled(subscriptionId); + } + + /// @notice Calculates subscription `interval` based on `activeAt` and `period` + /// @param activeAt when does a subscription start accepting callback responses + /// @param period time, in seconds, between each subscription response `interval` + /// @return current subscription interval + function getSubscriptionInterval(uint32 activeAt, uint32 period) public view returns (uint32) { + // If period is 0, we're always at interval 1 + if (period == 0) { + return 1; + } + + // Else, interval = ((block.timestamp - activeAt) / period) + 1 + // This is only called after validating block.timestamp >= activeAt so timestamp can't underflow + // We also short-circuit above if period is zero so no need for division by zero checks + unchecked { + return ((uint32(block.timestamp) - activeAt) / period) + 1; + } + } + + /// @notice Allows nodes with `Manager.NodeStatus.Active` to deliver container compute responses for a subscription + /// @dev Re-entering does not work because only active nodes (max 1 response) can call `deliverCompute` + /// @dev Re-entering and delivering via a seperate node `msg.sender` works but is ignored in favor of explicit `maxGasLimit` + /// @dev For containers without succinctly-verifiable proofs, the `proof` field can be repurposed for arbitrary metadata + /// @dev Enforces an overhead delivery cost of `DELIVERY_OVERHEAD_WEI` and `0` additional overhead + /// @param subscriptionId subscription ID to deliver + /// @param deliveryInterval subscription `interval` to deliver + /// @param input optional off-chain container input recorded by Infernet node (empty, hashed input, processed input, or both) + /// @param output optional off-chain container output (empty, hashed output, processed output, both, or fallback: all encodeable data) + /// @param proof optional off-chain container execution proof (or arbitrary metadata) + function deliverCompute( + uint32 subscriptionId, + uint32 deliveryInterval, + bytes calldata input, + bytes calldata output, + bytes calldata proof + ) external onlyActiveNode { + _deliverComputeWithOverhead(subscriptionId, deliveryInterval, input, output, proof, 0); + } +} diff --git a/src/EIP712Coordinator.sol b/src/EIP712Coordinator.sol new file mode 100644 index 0000000..859824d --- /dev/null +++ b/src/EIP712Coordinator.sol @@ -0,0 +1,228 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {ECDSA} from "solady/utils/ECDSA.sol"; +import {Coordinator} from "./Coordinator.sol"; +import {EIP712} from "solady/utils/EIP712.sol"; +import {Delegator} from "./pattern/Delegator.sol"; + +/// @title EIP712Coordinator +/// @notice Coordinator enhanced with ability to created subscriptions via off-chain EIP-712 signature +/// @dev Allows creating a subscription on behalf of a contract via delegatee EOA signature +/// @dev Allows nodes to atomically create subscriptions and deliver compute responses +contract EIP712Coordinator is EIP712, Coordinator { + /*////////////////////////////////////////////////////////////// + CONSTANTS + //////////////////////////////////////////////////////////////*/ + + /// @notice EIP-712 signing domain major version + string public constant EIP712_VERSION = "1"; + + /// @notice EIP-712 signing domain name + string public constant EIP712_NAME = "InfernetCoordinator"; + + /// @notice Gas overhead in wei to retrieve cached subscriptionId for existing delegatee-created subscription + /// @dev A uint16 is sufficient but increases control plane costs. While we can pack this and the subsequent uint24 + /// in contract storage to save data plane costs, we prioritize control plane and instead simply use a uint256 + uint256 public constant DELEGATEE_OVERHEAD_CACHED_WEI = 600 wei; + + /// @notice Gas overhead in wei to create a new subscription via delegatee signature + /// @dev Make note that this does not account for gas costs of dynamic inputs (containerId, inputs), just base overhead + /// @dev Can fit within uint24, see comment for `DELEGATEE_OVERHEAD_CACHED_WEI` for details + uint256 public constant DELEGATEE_OVERHEAD_CREATE_WEI = 91_200 wei; + + /// @notice EIP-712 struct(Subscription) typeHash + bytes32 private constant EIP712_SUBSCRIPTION_TYPEHASH = keccak256( + "Subscription(address owner,uint32 activeAt,uint32 period,uint32 frequency,uint16 redundancy,uint48 maxGasPrice,uint32 maxGasLimit,string containerId,bytes inputs)" + ); + + /// @notice EIP-712 struct(DelegateSubscription) typeHash + /// @dev struct(DelegateSubscription) == { uint32 nonce, uint32 expiry, Subscription sub } + /// @dev The `nonce` represents the nonce of the subscribing contract (sub-owner); prevents signature replay + /// @dev The `expiry` is when the delegated subscription signature expires and can no longer be used + bytes32 private constant EIP712_DELEGATE_SUBSCRIPTION_TYPEHASH = keccak256( + "DelegateSubscription(uint32 nonce,uint32 expiry,Subscription sub)Subscription(address owner,uint32 activeAt,uint32 period,uint32 frequency,uint16 redundancy,uint48 maxGasPrice,uint32 maxGasLimit,string containerId,bytes inputs)" + ); + + /*////////////////////////////////////////////////////////////// + MUTABLE + //////////////////////////////////////////////////////////////*/ + + /// @notice Subscribing contract => maximum seen nonce + /// @dev The nonce is a uint32 size(4.2B) which would take > 100 years of incrementing nonce per second to overflow + mapping(address => uint32) public maxSubscriberNonce; + + /// @notice hash(subscribing contract, nonce) => subscriptionId + /// @notice Allows lookup between a delegated subscription creation (unique(subscriber, nonce)) and subscriptionId + mapping(bytes32 => uint32) public delegateCreatedIds; + + /*////////////////////////////////////////////////////////////// + ERRORS + //////////////////////////////////////////////////////////////*/ + + /// @notice Thrown by `createSubscriptionDelegatee()` if subscription signature does not match contract delegatee + /// @dev 4-byte signature: `0x10c74b03` + error SignerMismatch(); + + /// @notice Thrown by `createSubscriptionDelegatee()` if signature for delegated subscription has expired + /// @dev 4-byte signature: `0x0819bdcd` + error SignatureExpired(); + + /*////////////////////////////////////////////////////////////// + OVERRIDE FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Overrides Solady.EIP712._domainNameAndVersion to return EIP712-compatible domain name, version + function _domainNameAndVersion() internal pure override returns (string memory, string memory) { + return (EIP712_NAME, EIP712_VERSION); + } + + /// @notice Overrides Solady.EIP712._domainNameAndVersionMayChange to always return false since the domain params are not updateable + function _domainNameAndVersionMayChange() internal pure override returns (bool) { + return false; + } + + /*////////////////////////////////////////////////////////////// + FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Allows a delegatee to create a subscription on behalf of a subscribing contract (sub.owner) + /// @dev Unlike `Coordinator.createSubscription()`, offers maximum flexibility to set subscription parameters + /// @param nonce subscribing contract nonce (included in signature) + /// @param expiry delegated subscription signature expiry (included in signature) + /// @param sub subscription to create + /// @param v ECDSA recovery id + /// @param r ECDSA signature output (r) + /// @param s ECDSA signature output (s) + /// @return 0: subscriptionId (if subscription exists, returns existing ID, else returns new ID), + /// 1: exists (true if returning existing subscription, else false) + function createSubscriptionDelegatee( + uint32 nonce, + uint32 expiry, + Subscription calldata sub, + uint8 v, + bytes32 r, + bytes32 s + ) public returns (uint32, bool) { + // Check if subscription already exists via delegate-created lookup table + bytes32 key = keccak256(abi.encode(sub.owner, nonce)); + uint32 subscriptionId = delegateCreatedIds[key]; + + // If subscription exists, return existing subscriptionId + // This implicitly prevents nonce replay because if the nonce was already used, a subscription would exist + if (subscriptionId != 0) { + return (subscriptionId, true); + } + + // Else, if subscription does not exist + // First, verify that signature has not expired + if (uint32(block.timestamp) >= expiry) { + revert SignatureExpired(); + } + + // Generate EIP-712 data + bytes32 digest = _hashTypedData( + keccak256( + // Encode(DelegateSubscription, nonce, expiry, sub) + abi.encode( + EIP712_DELEGATE_SUBSCRIPTION_TYPEHASH, + nonce, + expiry, + // Encode(Subscription, sub) + keccak256( + abi.encode( + EIP712_SUBSCRIPTION_TYPEHASH, + sub.owner, + sub.activeAt, + sub.period, + sub.frequency, + sub.redundancy, + sub.maxGasPrice, + sub.maxGasLimit, + // Hash dynamic values + keccak256(bytes(sub.containerId)), + keccak256(sub.inputs) + ) + ) + ) + ) + ); + + // Get recovered signer from data + // Throws `InvalidSignature()` (4-byte signature: `0x8baa579f`) if can't recover signer + address recoveredSigner = ECDSA.recover(digest, v, r, s); + + // Collect delegated signer from subscribing contract + address delegatedSigner = Delegator(sub.owner).signer(); + + // Verify signatures (recoveredSigner should equal delegatedSigner) + if (recoveredSigner != delegatedSigner) { + revert SignerMismatch(); + } + + // By this point, the signer is verified and a net-new subscription can be created + // Assign new subscription id + // Unlikely this will ever overflow so we can toss in unchecked + unchecked { + subscriptionId = id++; + } + + // Store provided subscription as-is + subscriptions[subscriptionId] = sub; + + // Update delegate-created ID lookup table + delegateCreatedIds[key] = subscriptionId; + + // Emit new subscription + emit SubscriptionCreated(subscriptionId); + + // Update max known subscriber nonce (useful for off-chain signing utilities to prevent nonce-collision) + if (nonce > maxSubscriberNonce[sub.owner]) { + maxSubscriberNonce[sub.owner] = nonce; + } + + // Explicitly return subscriptionId + return (subscriptionId, false); + } + + /// @notice Allows active nodes to (1) atomically create or collect subscription via signed EIP-712 message, + /// (2) deliver container compute responses for created or collected subscription + /// @param nonce subscribing contract nonce (included in signature) + /// @param expiry delegated subscription signature expiry (included in signature) + /// @param sub subscription to create + /// @param v ECDSA recovery id + /// @param r ECDSA signature output (r) + /// @param s ECDSA signature output (s) + /// @param deliveryInterval subscription `interval` + /// @param input optional off-chain input recorded by Infernet node (empty, hashed input, processed input, or both) + /// @param output optional off-chain container output (empty, hashed output, processed output, both, or fallback: all encodeable data) + /// @param proof optional container execution proof (or arbitrary metadata) + function deliverComputeDelegatee( + uint32 nonce, + uint32 expiry, + Subscription calldata sub, + uint8 v, + bytes32 r, + bytes32 s, + uint32 deliveryInterval, + bytes calldata input, + bytes calldata output, + bytes calldata proof + ) external onlyActiveNode { + // Create subscriptionId via delegatee creation + or collect if subscription already exists + (uint32 subscriptionId, bool cached) = createSubscriptionDelegatee(nonce, expiry, sub, v, r, s); + + // Calculate additional gas overhead imposed from delivering container compute response via delegatee function + uint256 overhead; + if (cached) { + // Subscription exists, cost to retrieve subscriptionId + overhead = DELEGATEE_OVERHEAD_CACHED_WEI; + } else { + // Subscription does not exist, cost to create subscription w/ delegatee signature + overhead = DELEGATEE_OVERHEAD_CREATE_WEI; + } + + // Deliver subscription response + _deliverComputeWithOverhead(subscriptionId, deliveryInterval, input, output, proof, overhead); + } +} diff --git a/src/Manager.sol b/src/Manager.sol new file mode 100644 index 0000000..8495584 --- /dev/null +++ b/src/Manager.sol @@ -0,0 +1,190 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +/// @title Manager +/// @notice Manages node lifecycle (registration, activation, deactivation) +/// @dev Allows anyone to register to become an active node +/// @dev Allows registered nodes to become active after a `cooldown` seconds waiting period +/// @dev Allows any node to deactivate itself and return to an inactive state +/// @dev Exposes an `onlyActiveNode()` modifier used to restrict functions to being called by only active nodes +/// @dev Restricts addresses to 1 of 3 states: `Inactive`, `Registered`, `Active` +abstract contract Manager { + /*////////////////////////////////////////////////////////////// + STRUCTS + //////////////////////////////////////////////////////////////*/ + + /// @notice Packed information about a node (status, cooldown start) + /// @dev Cheaper to use a struct to store `status` + `cooldownStart` rather than SSTORE 2 independent mappings + /// @dev Technically, could bitshift pack uint40 of data into single uint256 but readability penalty not worth it + /// @dev Tightly-packed (well under 32-byte slot): [uint8, uint32] = 40 bits = 5 bytes + struct NodeInfo { + /// @notice Node status + NodeStatus status; + /// @notice Cooldown start timestamp in seconds + /// @dev Default initializes to `0`; no cooldown active to start + /// @dev Equal to `0` if `status != NodeStatus.Registered`, else equal to cooldown start time + /// @dev Is modified by `registerNode()` to initiate `cooldown` holding period + /// @dev uint32 allows for a timestamp up to year ~2106, likely far beyond lifecycle of this contract + uint32 cooldownStart; + } + + /*////////////////////////////////////////////////////////////// + ENUMS + //////////////////////////////////////////////////////////////*/ + + /// @notice Possible node statuses + /// @dev Enums in Solidity are unsigned integers capped at 256 members, so Inactive is the 0-initialized default + /// @dev Inactive (0): Default status is inactive; no status + /// @dev Registered (1): Node has registered to become active, initiating a period of `cooldown` + /// @dev Active (2): Node is active, able to fulfill subscriptions, and is part of `modifier(onlyActiveNode)` + enum NodeStatus { + Inactive, + Registered, + Active + } + + /*////////////////////////////////////////////////////////////// + CONSTANTS + //////////////////////////////////////////////////////////////*/ + + /// @notice Cooldown period, in seconds, before a node with `NodeStatus.Registered` can call `activateNode()` + /// @dev type(uint32) is sufficient but we are not packing variables so control plane costs are higher because we + /// need to cast the 32-bit type into the 256-bit type anyways. Thus, we use type(uint256). + uint256 public constant cooldown = 1 hours; + + /*////////////////////////////////////////////////////////////// + MUTABLE + //////////////////////////////////////////////////////////////*/ + + /// @dev Node address => node information + mapping(address => NodeInfo) public nodeInfo; + + /*////////////////////////////////////////////////////////////// + EVENTS + //////////////////////////////////////////////////////////////*/ + + /// @notice Emitted when a node moves from `NodeStatus.Inactive` to `NodeStatus.Registered` + /// @dev It's actually slightly more expensive (~6 gas) to emit the uint32 given the explicit conversion needed + /// but this is necessary to have better readability and uniformity across the type (not casting in event) + /// @param node newly-registered node address + /// @param registerer optional proxy address registering on behalf of node (is equal to node when self-registering) + /// @param cooldownStart start timestamp of registration cooldown + event NodeRegistered(address indexed node, address indexed registerer, uint32 cooldownStart); + + /// @notice Emitted when a node moves from `NodeStatus.Registered` to `NodeStatus.Active` + /// @param node newly-activated node address + event NodeActivated(address indexed node); + + /// @notice Emitted when a node moves from any status to `NodeStatus.Inactive` + /// @param node newly-deactivated node address + event NodeDeactivated(address indexed node); + + /*////////////////////////////////////////////////////////////// + ERRORS + //////////////////////////////////////////////////////////////*/ + + /// @notice Thrown if attempting to call function that requires a node to have status `NodeStatus.Active` + /// @dev Only used by `modifier(onlyActiveNode)` + /// @dev 4-byte signature: `0x8741cbb8` + error NodeNotActive(); + + /// @notice Thrown by `registerNode()` if attempting to register node with status that is not `NodeStatus.Inactive` + /// @dev 4-byte signature: `0x5acfd518` + /// @param node address of node attempting to register + /// @param status current status of node failing registration + error NodeNotRegisterable(address node, NodeStatus status); + + /// @notice Thrown by `activateNode()` if `cooldown` has not elapsed since node was registered + /// @dev Like `NodeRegistered`, slightly more expensive to use uint32 over uint256 (~6 gas) but better readability + /// @dev 4-byte signature: `0xc84b5bdd` + /// @param cooldownStart start timestamp of node cooldown + error CooldownActive(uint32 cooldownStart); + + /// @notice Thrown by `activateNode()` if attempting to active node with status that is not `NodeStatus.Registered` + /// @dev 4-byte signature: `0x33daa7f9` + /// @param status current status of node failing activation + error NodeNotActivateable(NodeStatus status); + + /*////////////////////////////////////////////////////////////// + MODIFIERS + //////////////////////////////////////////////////////////////*/ + + /// @notice Allow only callers that are active nodes + modifier onlyActiveNode() { + if (nodeInfo[msg.sender].status != NodeStatus.Active) { + revert NodeNotActive(); + } + _; + } + + /*////////////////////////////////////////////////////////////// + FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Allows registering a node for activation + /// @dev First-step of two-step process (followed by `activateNode()`) + /// @dev Can call on behalf of other nodes as a proxy registerer + /// @dev Node must have `NodeStatus.Inactive` to begin registration + /// @param node node address to register + function registerNode(address node) external { + // SLOAD node info + NodeInfo storage info = nodeInfo[node]; + + // Ensure node is registerable + // Current status must be `NodeStatus.Inactive` + if (info.status != NodeStatus.Inactive) { + revert NodeNotRegisterable(node, info.status); + } + + // Update node status to Registered + info.status = NodeStatus.Registered; + // Update cooldown start timestamp to now + info.cooldownStart = uint32(block.timestamp); + + // Emit new registration event + emit NodeRegistered(node, msg.sender, uint32(block.timestamp)); + } + + /// @notice Allows activating a registered node after `cooldown` has elapsed + /// @dev Second-step of two-step process (preceeded by `registerNode()`) + /// @dev Must be called by node accepting a pending registration (`msg.sender == node`) + /// @dev Must be called at least `cooldown` seconds after `registerNode()` + function activateNode() external { + // SLOAD node info + NodeInfo storage info = nodeInfo[msg.sender]; + + // Ensure node is already registered + // Technically this check is not needed since the next check would fail anyways, but it provides a useful error + if (info.status != NodeStatus.Registered) { + revert NodeNotActivateable(info.status); + } + + // Ensure node has elapsed required cooldown + // Adding a uint32 to a uint32-bounded uint256 and upcasting to a uint256, so can't overflow + uint256 cooldownEnd; + unchecked { + cooldownEnd = info.cooldownStart + cooldown; + } + if (block.timestamp < cooldownEnd) { + revert CooldownActive(info.cooldownStart); + } + + // Toggle node status to Active + info.status = NodeStatus.Active; + // Reset cooldown start timestamp + info.cooldownStart = 0; + + // Emit activation event + emit NodeActivated(msg.sender); + } + + /// @notice Allows deactivating a node + /// @dev Can be called to set the status of any node back to `NodeStatus.Inactive` with no cooldown + /// @dev Must be called by the node deactivating itself (`msg.sender == node`) + function deactivateNode() external { + delete nodeInfo[msg.sender]; + + // Emit deactivation event + emit NodeDeactivated(msg.sender); + } +} diff --git a/src/consumer/Base.sol b/src/consumer/Base.sol new file mode 100644 index 0000000..0542572 --- /dev/null +++ b/src/consumer/Base.sol @@ -0,0 +1,92 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {Coordinator} from "../Coordinator.sol"; + +/// @title BaseConsumer +/// @notice Handles receiving container compute responses from Infernet coordinator +/// @dev Contains a single public entrypoint `rawReceiveCompute` callable by only the Infernet coordinator. Once +/// call origin is verified, parameters are proxied to internal function `_receiveCompute` +abstract contract BaseConsumer { + /*////////////////////////////////////////////////////////////// + IMMUTABLE + //////////////////////////////////////////////////////////////*/ + + /// @notice Infernet Coordinator + /// @dev Internal visibility since COORDINATOR is consumed by inheriting contracts + Coordinator internal immutable COORDINATOR; + + /*////////////////////////////////////////////////////////////// + ERRORS + //////////////////////////////////////////////////////////////*/ + + /// @notice Thrown if attempting to call `rawReceiveCompute` from a `msg.sender != address(COORDINATOR)` + /// @dev 4-byte signature: `0x9ec853e6` + error NotCoordinator(); + + /*////////////////////////////////////////////////////////////// + CONSTRUCTOR + //////////////////////////////////////////////////////////////*/ + + /// @notice Initialize new BaseConsumer + /// @param coordinator coordinator address + constructor(address coordinator) { + // Setup Coordinator + COORDINATOR = Coordinator(coordinator); + } + + /*////////////////////////////////////////////////////////////// + VIRTUAL FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Callback entrypoint to receive container compute responses from validated Coordinator source + /// @dev Called by `rawReceiveCompute` once validated that `msg.sender == address(COORDINATOR)` + /// @dev Same function parameters as `rawReceiveCompute` + /// @param subscriptionId id of subscription being responded to + /// @param interval subscription interval + /// @param redundancy after this call succeeds, how many nodes will have delivered a response for this interval + /// @param node address of responding Infernet node + /// @param input optional off-chain container input recorded by Infernet node (empty, hashed input, processed input, or both) + /// @param output optional off-chain container output (empty, hashed output, processed output, both, or fallback: all encodeable data) + /// @param proof optional off-chain container execution proof (or arbitrary metadata) + function _receiveCompute( + uint32 subscriptionId, + uint32 interval, + uint16 redundancy, + address node, + bytes calldata input, + bytes calldata output, + bytes calldata proof + ) internal virtual {} + + /*////////////////////////////////////////////////////////////// + FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Callback entrypoint called by Infernet Coordinator to return container compute responses + /// @dev Callable only by `address(COORDINATOR)`, else throws `NotCoordinator()` error + /// @param subscriptionId id of subscription being responded to + /// @param interval subscription interval + /// @param redundancy after this call succeeds, how many nodes will have delivered a response for this interval + /// @param node address of responding Infernet node + /// @param input optional off-chain container input recorded by Infernet node (empty, hashed input, processed input, or both) + /// @param output optional off-chain container output (empty, hashed output, processed output, both, or fallback: all encodeable data) + /// @param proof optional off-chain container execution proof (or arbitrary metadata) + function rawReceiveCompute( + uint32 subscriptionId, + uint32 interval, + uint16 redundancy, + address node, + bytes calldata input, + bytes calldata output, + bytes calldata proof + ) external { + // Ensure caller is coordinator + if (msg.sender != address(COORDINATOR)) { + revert NotCoordinator(); + } + + // Call internal receive function, since caller is validated + _receiveCompute(subscriptionId, interval, redundancy, node, input, output, proof); + } +} diff --git a/src/consumer/Callback.sol b/src/consumer/Callback.sol new file mode 100644 index 0000000..bddc114 --- /dev/null +++ b/src/consumer/Callback.sol @@ -0,0 +1,49 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {BaseConsumer} from "./Base.sol"; + +/// @title CallbackConsumer +/// @notice Allows creating one-time requests for off-chain container compute, delivered via callback +/// @dev Inherits `BaseConsumer` to inherit functions to receive container compute responses +abstract contract CallbackConsumer is BaseConsumer { + /*////////////////////////////////////////////////////////////// + CONSTRUCTOR + //////////////////////////////////////////////////////////////*/ + + /// @notice Initialize new CallbackConsumer + /// @param coordinator coordinator address + constructor(address coordinator) BaseConsumer(coordinator) {} + + /*////////////////////////////////////////////////////////////// + INTERNAL FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Creates a one-time request for off-chain container compute via callback + /// @dev Under the hood, creates a new subscription at the Infernet coordinator, with `period == 0` and + /// `frequency == 1`, effectively initializing a subscription valid immediately and only for 1 interval + /// @param containerId compute container identifier(s) used by off-chain Infernet node + /// @param inputs optional container inputs + /// @param maxGasPrice max gas price in wei paid by Infernet node when fulfilling callback + /// @param maxGasLimit max gas limit in wei used by Infernet node in callback tx + /// @param redundancy number of unique responding Infernet nodes + /// @return subscription ID of newly-created one-time subscription + function _requestCompute( + string memory containerId, + bytes memory inputs, + uint48 maxGasPrice, + uint32 maxGasLimit, + uint16 redundancy + ) internal returns (uint32) { + // Create one-time subscription at coordinator + return COORDINATOR.createSubscription( + containerId, + inputs, + maxGasPrice, + maxGasLimit, + 1, // frequency == 1, one-time subscription + 0, // period == 0, available to be responded to immediately + redundancy + ); + } +} diff --git a/src/consumer/Subscription.sol b/src/consumer/Subscription.sol new file mode 100644 index 0000000..e9e3412 --- /dev/null +++ b/src/consumer/Subscription.sol @@ -0,0 +1,73 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {BaseConsumer} from "./Base.sol"; + +/// @title SubscriptionConsumer +/// @notice Allows creating recurring subscriptions for off-chain container compute +/// @dev Inherits `BaseConsumer` to inherit functions to receive container compute responses +abstract contract SubscriptionConsumer is BaseConsumer { + /*////////////////////////////////////////////////////////////// + CONSTRUCTOR + //////////////////////////////////////////////////////////////*/ + + /// @notice Initialize new SubscriptionConsumer + /// @param coordinator coordinator address + constructor(address coordinator) BaseConsumer(coordinator) {} + + /*////////////////////////////////////////////////////////////// + VIRTUAL FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice View function to broadcast dynamic container inputs to off-chain Infernet nodes + /// @dev If `Coordinator.subscription[id].inputs == bytes("")`, a off-chain node will call `getContainerInputs()` + /// to retrieve inputs. Develpers can modify this function to return dynamic inputs + /// @param subscriptionId subscription ID to collect container inputs for + /// @param interval subscription interval to collect container inputs for + /// @param timestamp timestamp at which container inputs are collected + /// @param caller calling address + function getContainerInputs(uint32 subscriptionId, uint32 interval, uint32 timestamp, address caller) + external + view + virtual + returns (bytes memory) + {} + + /*////////////////////////////////////////////////////////////// + INTERNAL FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Creates a recurring request for off-chain container compute via callback response + /// @param containerId compute container identifier(s) used by off-chain Infernet node + /// @param maxGasPrice max gas price in wei paid by Infernet node when fulfilling callback + /// @param maxGasLimit max gas limit in wei paid by Infernet node in callback tx + /// @param frequency max number of times to process subscription (i.e, `frequency == 1` is a one-time request) + /// @param period period, in seconds, at which to progress each responding `interval` + /// @param redundancy number of unique responding Infernet nodes + /// @return subscription ID of newly-created subscription + function _createComputeSubscription( + string memory containerId, + uint48 maxGasPrice, + uint32 maxGasLimit, + uint32 frequency, + uint32 period, + uint16 redundancy + ) internal returns (uint32) { + return COORDINATOR.createSubscription( + containerId, + "", // Infernet nodes call `getContainerInputs()` to retrieve dynamic inputs + maxGasPrice, + maxGasLimit, + frequency, + period, + redundancy + ); + } + + /// @notice Cancels a created subscription + /// @dev Can only cancel owned subscriptions (`address(this) == Coordinator.subscriptions[subscriptionId].owner`) + /// @param subscriptionId ID of subscription to cancel + function _cancelComputeSubscription(uint32 subscriptionId) internal { + COORDINATOR.cancelSubscription(subscriptionId); + } +} diff --git a/src/pattern/Delegator.sol b/src/pattern/Delegator.sol new file mode 100644 index 0000000..4ffcfe5 --- /dev/null +++ b/src/pattern/Delegator.sol @@ -0,0 +1,38 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +/// @title Delegator +/// @notice Exposes a `signer` address that allows an authorized EOA to sign off on actions on behalf of a contract +/// @dev Allows developers to create Coordinator subscriptions off-chain, on behalf of a contract, by signing a +/// `DelegateSubscription` from `signer` and submitting to `EIP712Coordinator.createSubscriptionDelegatee()` +abstract contract Delegator { + /*////////////////////////////////////////////////////////////// + MUTABLE + //////////////////////////////////////////////////////////////*/ + + /// @notice Authorized address with signing privileges + /// @dev Recommended to use an EOA so that it can sign EIP-712 messages + /// @dev Visibility is `public` to automatically generate and expose a getter + address public signer; + + /*////////////////////////////////////////////////////////////// + CONSTRUCTOR + //////////////////////////////////////////////////////////////*/ + + /// @notice Initialize new Delegator + /// @param signer_ authorized address + constructor(address signer_) { + signer = signer_; + } + + /*////////////////////////////////////////////////////////////// + INTERNAL FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Update delegated signer + /// @dev No event is emitted given contract is meant to be inherited + /// @param newSigner new delegated signer address + function _updateSigner(address newSigner) internal { + signer = newSigner; + } +} diff --git a/test/Coordinator.t.sol b/test/Coordinator.t.sol new file mode 100644 index 0000000..dff6d73 --- /dev/null +++ b/test/Coordinator.t.sol @@ -0,0 +1,706 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {Test} from "forge-std/Test.sol"; +import {Manager} from "../src/Manager.sol"; +import {LibStruct} from "./lib/LibStruct.sol"; +import {MockNode} from "./mocks/MockNode.sol"; +import {Ownable} from "solady/auth/Ownable.sol"; +import {Coordinator} from "../src/Coordinator.sol"; +import {BaseConsumer} from "../src/consumer/Base.sol"; +import {MockBaseConsumer} from "./mocks/consumer/Base.sol"; +import {EIP712Coordinator} from "../src/EIP712Coordinator.sol"; +import {MockCallbackConsumer} from "./mocks/consumer/Callback.sol"; +import {MockSubscriptionConsumer} from "./mocks/consumer/Subscription.sol"; + +/// @title ICoordinatorEvents +/// @notice Events emitted by Coordinator +interface ICoordinatorEvents { + event SubscriptionCreated(uint32 indexed id); + event SubscriptionCancelled(uint32 indexed id); + event SubscriptionFulfilled(uint32 indexed id, address indexed node); +} + +/// @title CoordinatorConstants +/// @notice Base constants setup to inherit for Coordinator subtests +abstract contract CoordinatorConstants { + /*////////////////////////////////////////////////////////////// + CONSTANTS + //////////////////////////////////////////////////////////////*/ + + /// @notice Mock compute container ID + string constant MOCK_CONTAINER_ID = "container"; + + /// @notice Mock container inputs + bytes constant MOCK_CONTAINER_INPUTS = "inputs"; + + /// @notice Mock delivered container input + /// @dev Example of a hashed input (encoding hash(MOCK_CONTAINER_INPUTS) into input) field + bytes constant MOCK_INPUT = abi.encode(keccak256(abi.encode(MOCK_CONTAINER_INPUTS))); + + /// @notice Mock delivered container compute output + bytes constant MOCK_OUTPUT = "output"; + + /// @notice Mock delivered proof + bytes constant MOCK_PROOF = "proof"; + + /// @notice Cold cost of CallbackConsumer.rawReceiveCompute + /// @dev Inputs: (uint32, uint32, uint16, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF) + uint32 constant COLD_DELIVERY_COST_CALLBACK = 115_076 wei; + + /// @notice Cold cost of SubscriptionConsumer.rawReceiveCompute + /// @dev Inputs: (uint32, uint32, uint16, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF) + uint32 constant COLD_DELIVERY_COST_SUBSCRIPTION = 115_160 wei; +} + +/// @title CoordinatorTest +/// @notice Base setup to inherit for Coordinator subtests +abstract contract CoordinatorTest is Test, CoordinatorConstants, ICoordinatorEvents { + /*////////////////////////////////////////////////////////////// + INTERNAL + //////////////////////////////////////////////////////////////*/ + + /// @notice Coordinator + Coordinator internal COORDINATOR; + + /// @notice Mock node (Alice) + MockNode internal ALICE; + + /// @notice Mock node (Bob) + MockNode internal BOB; + + /// @notice Mock node (Charlie) + MockNode internal CHARLIE; + + /// @notice Mock callback consumer + MockCallbackConsumer internal CALLBACK; + + /// @notice Mock subscription consumer + MockSubscriptionConsumer internal SUBSCRIPTION; + + /*////////////////////////////////////////////////////////////// + SETUP + //////////////////////////////////////////////////////////////*/ + + function setUp() public { + // Initialize coordinator + COORDINATOR = new Coordinator(); + + // Initalize mock nodes + // Forcefully cast to EIP712Coordinator (not using additional functionality in current tests) + ALICE = new MockNode(EIP712Coordinator(address(COORDINATOR))); + BOB = new MockNode(EIP712Coordinator(address(COORDINATOR))); + CHARLIE = new MockNode(EIP712Coordinator(address(COORDINATOR))); + + // For each node + MockNode[3] memory nodes = [ALICE, BOB, CHARLIE]; + for (uint256 i = 0; i < 3; i++) { + // Select node + MockNode node = nodes[i]; + + // Activate node + vm.warp(0); + node.registerNode(address(node)); + vm.warp(COORDINATOR.cooldown()); + node.activateNode(); + } + + // Initialize mock callback consumer + CALLBACK = new MockCallbackConsumer( + address(COORDINATOR) + ); + + // Initialize mock subscription consumer + SUBSCRIPTION = new MockSubscriptionConsumer( + address(COORDINATOR) + ); + } +} + +/// @title CoordinatorGeneralTest +/// @notice General coordinator tests +contract CoordinatorGeneralTest is CoordinatorTest { + /// @notice Cannot be reassigned a subscription ID + function testCannotBeReassignedSubscriptionID() public { + // Create new callback subscription + uint32 id = CALLBACK.createMockRequest(MOCK_CONTAINER_ID, MOCK_CONTAINER_INPUTS, 1 gwei, 100_000, 1); + assertEq(id, 1); + + // Create new subscriptions + CALLBACK.createMockRequest(MOCK_CONTAINER_ID, MOCK_CONTAINER_INPUTS, 1 gwei, 100_000, 1); + CALLBACK.createMockRequest(MOCK_CONTAINER_ID, MOCK_CONTAINER_INPUTS, 1 gwei, 100_000, 1); + CALLBACK.createMockRequest(MOCK_CONTAINER_ID, MOCK_CONTAINER_INPUTS, 1 gwei, 100_000, 1); + + // Assert head + assertEq(COORDINATOR.id(), 5); + + // Delete subscriptions + vm.startPrank(address(CALLBACK)); + COORDINATOR.cancelSubscription(1); + COORDINATOR.cancelSubscription(3); + + // Assert head + assertEq(COORDINATOR.id(), 5); + + // Create new subscription + id = CALLBACK.createMockRequest(MOCK_CONTAINER_ID, MOCK_CONTAINER_INPUTS, 1 gwei, 100_000, 1); + assertEq(id, 5); + assertEq(COORDINATOR.id(), 6); + } + + /// @notice Cannot receive response from non-coordinator contract + function testCannotReceiveResponseFromNonCoordinator() public { + // Expect revert sending from address(this) + vm.expectRevert(BaseConsumer.NotCoordinator.selector); + CALLBACK.rawReceiveCompute(1, 1, 1, address(this), MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } +} + +/// @title CoordinatorCallbackTest +/// @notice Coordinator tests specific to usage by CallbackConsumer +contract CoordinatorCallbackTest is CoordinatorTest { + /// @notice Can create callback (one-time subscription) + function testCanCreateCallback() public { + vm.warp(0); + + // Get expected subscription ID + uint32 expected = COORDINATOR.id(); + + // Create new callback + vm.expectEmit(address(COORDINATOR)); + emit SubscriptionCreated(expected); + uint32 actual = CALLBACK.createMockRequest(MOCK_CONTAINER_ID, MOCK_CONTAINER_INPUTS, 1 gwei, 100_000, 1); + + // Assert subscription ID is correctly stored + assertEq(expected, actual); + + // Assert subscription data is correctly stored + LibStruct.Subscription memory sub = LibStruct.getSubscription(COORDINATOR, actual); + assertEq(sub.activeAt, 0); + assertEq(sub.owner, address(CALLBACK)); + assertEq(sub.maxGasPrice, 1 gwei); + assertEq(sub.redundancy, 1); + assertEq(sub.maxGasLimit, 100_000); + assertEq(sub.frequency, 1); + assertEq(sub.period, 0); + assertEq(sub.containerId, MOCK_CONTAINER_ID); + assertEq(sub.inputs, MOCK_CONTAINER_INPUTS); + } + + /// @notice Cannot deliver callback response if maxGasPrice too low + function testCannotDeliverCallbackMaxGasPriceTooLow() public { + // Create new subscription with 1 gwei max fee + uint32 subId = CALLBACK.createMockRequest(MOCK_CONTAINER_ID, MOCK_CONTAINER_INPUTS, 1 gwei, 100_000, 1); + + // Set tx gas price to 1gwei + 1wei + vm.txGasPrice(1 gwei + 1 wei); + + // Attempt to deliver new subscription + vm.expectRevert(Coordinator.GasPriceExceeded.selector); + ALICE.deliverCompute(subId, 1, "", "", ""); + } + + /// @notice Cannot deliver callback response if incorrect interval + function testFuzzCannotDeliverCallbackIfIncorrectInterval(uint32 interval) public { + // Check non-correct intervals + vm.assume(interval != 1); + + // Create new callback request + uint32 subId = CALLBACK.createMockRequest(MOCK_CONTAINER_ID, MOCK_CONTAINER_INPUTS, 1 gwei, 100_000, 1); + + // Attempt to deliver callback request w/ incorrect interval + vm.expectRevert(Coordinator.IntervalMismatch.selector); + ALICE.deliverCompute(subId, interval, "", "", ""); + } + + /// @notice Can deliver callback response successfully + function testCanDeliverCallbackResponse() public { + // Create new callback request + uint32 subId = CALLBACK.createMockRequest( + MOCK_CONTAINER_ID, + MOCK_CONTAINER_INPUTS, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_CALLBACK, + 1 + ); + + // Deliver callback request + vm.expectEmit(address(COORDINATOR)); + emit SubscriptionFulfilled(subId, address(ALICE)); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + + // Assert delivery + LibStruct.DeliveredOutput memory out = LibStruct.getDeliveredOutput(CALLBACK, subId, 1, 1); + assertEq(out.subscriptionId, subId); + assertEq(out.interval, 1); + assertEq(out.redundancy, 1); + assertEq(out.node, address(ALICE)); + assertEq(out.input, MOCK_INPUT); + assertEq(out.output, MOCK_OUTPUT); + assertEq(out.proof, MOCK_PROOF); + } + + /// @notice Can deliver callback response once, across two unique nodes + function testCanDeliverCallbackResponseOnceAcrossTwoNodes() public { + // Create new callback request w/ redundancy = 2 + uint16 redundancy = 2; + uint32 subId = CALLBACK.createMockRequest( + MOCK_CONTAINER_ID, + MOCK_CONTAINER_INPUTS, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_CALLBACK, + redundancy + ); + + // Deliver callback request from two nodes + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + BOB.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + + // Assert delivery + address[2] memory nodes = [address(ALICE), address(BOB)]; + for (uint16 r = 1; r <= 2; r++) { + LibStruct.DeliveredOutput memory out = LibStruct.getDeliveredOutput(CALLBACK, subId, 1, r); + assertEq(out.subscriptionId, subId); + assertEq(out.interval, 1); + assertEq(out.redundancy, r); + assertEq(out.node, nodes[r - 1]); + assertEq(out.input, MOCK_INPUT); + assertEq(out.output, MOCK_OUTPUT); + assertEq(out.proof, MOCK_PROOF); + } + } + + /// @notice Cannot deliver callback response twice from same node + function testCannotDeliverCallbackResponseFromSameNodeTwice() public { + // Create new callback request w/ redundancy = 2 + uint16 redundancy = 2; + uint32 subId = CALLBACK.createMockRequest( + MOCK_CONTAINER_ID, + MOCK_CONTAINER_INPUTS, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_CALLBACK, + redundancy + ); + + // Deliver callback request from Alice twice + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + vm.expectRevert(Coordinator.NodeRespondedAlready.selector); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Cannot deliver callback with insufficient gas limit + function testCannotDeliverCallbackWithInsufficientGasLimit() public { + // Create new callback request with maxGasLimit < 100 wei less than necessary + vm.warp(0); + uint32 subId = CALLBACK.createMockRequest( + MOCK_CONTAINER_ID, + MOCK_CONTAINER_INPUTS, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_CALLBACK - 100, + 1 + ); + + // Ensure that fulfilling callback fails + vm.warp(1 minutes); + vm.expectRevert(abi.encodeWithSelector(Coordinator.GasLimitExceeded.selector)); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Callback gas limit constant is approximately correct + function testCallbackGasLimitIsApproximatelyCorrect() public { + // Calculate approximate expected gas consumed + uint256 expectedGasConsumed = uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_CALLBACK; + uint256 threePercentDelta = ((expectedGasConsumed * 103) / 100) - expectedGasConsumed; + + // Create new callback request with appropriate maxGasLimit + vm.warp(0); + uint32 subId = CALLBACK.createMockRequest( + MOCK_CONTAINER_ID, + MOCK_CONTAINER_INPUTS, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_CALLBACK, + 1 + ); + + // Deliver callback directly as Alice and measure gas consumed + vm.warp(1 minutes); + vm.startPrank(address(ALICE)); + uint256 startingGas = gasleft(); + COORDINATOR.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + uint256 endingGas = gasleft(); + uint256 actualGasConsumed = startingGas - endingGas; + + // Ensure that gas consumed via direct delivery is ~approximately same as what we'd mathematically expect + assertApproxEqAbs(actualGasConsumed, expectedGasConsumed, threePercentDelta); + } +} + +/// @title CoordinatorSubscriptionTest +/// @notice Coordintor tests specific to usage by SubscriptionConsumer +contract CoordinatorSubscriptionTest is CoordinatorTest { + /// @notice Can read container inputs + function testCanReadContainerInputs() public { + bytes memory expected = SUBSCRIPTION.CONTAINER_INPUTS(); + bytes memory actual = SUBSCRIPTION.getContainerInputs(0, 0, 0, address(this)); + assertEq(expected, actual); + } + + /// @notice Can cancel a subscription + function testCanCancelSubscription() public { + // Create subscription + uint32 subId = SUBSCRIPTION.createMockSubscription( + MOCK_CONTAINER_ID, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION, + 3, + 1 minutes, + 1 + ); + + // Cancel subscription and expect event emission + vm.expectEmit(address(COORDINATOR)); + emit SubscriptionCancelled(subId); + SUBSCRIPTION.cancelMockSubscription(subId); + } + + /// @notice Can cancel a subscription that has been fulfilled at least once + function testCanCancelFulfilledSubscription() public { + // Create subscription + vm.warp(0); + uint32 subId = SUBSCRIPTION.createMockSubscription( + MOCK_CONTAINER_ID, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION, + 3, + 1 minutes, + 1 + ); + + // Fulfill at least once + vm.warp(60); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + + // Cancel subscription + SUBSCRIPTION.cancelMockSubscription(subId); + } + + /// @notice Cannot cancel a subscription that does not exist + function testCannotCancelNonExistentSubscription() public { + // Try to delete subscription without creating + vm.expectRevert(Coordinator.NotSubscriptionOwner.selector); + SUBSCRIPTION.cancelMockSubscription(1); + } + + /// @notice Cannot cancel a subscription that has already been cancelled + function testCannotCancelCancelledSubscription() public { + // Create and cancel subscription + uint32 subId = SUBSCRIPTION.createMockSubscription( + MOCK_CONTAINER_ID, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION, + 3, + 1 minutes, + 1 + ); + SUBSCRIPTION.cancelMockSubscription(subId); + + // Attempt to cancel subscription again + vm.expectRevert(Coordinator.NotSubscriptionOwner.selector); + SUBSCRIPTION.cancelMockSubscription(subId); + } + + /// @notice Cannot cancel a subscription you do not own + function testCannotCancelUnownedSubscription() public { + // Create callback subscription + uint32 subId = CALLBACK.createMockRequest( + MOCK_CONTAINER_ID, + MOCK_CONTAINER_INPUTS, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION, + 1 + ); + + // Attempt to cancel subscription from SUBSCRIPTION consumer + vm.expectRevert(Coordinator.NotSubscriptionOwner.selector); + SUBSCRIPTION.cancelMockSubscription(subId); + } + + /// @notice Subscription intervals are properly calculated + function testFuzzSubscriptionIntervalsAreCorrect(uint32 blockTime, uint32 frequency, uint32 period) public { + // In the interest of testing time, upper bounding frequency loops + having at minimum 1 frequency + vm.assume(frequency > 1 && frequency < 32); + // Prevent upperbound overflow + vm.assume(uint256(blockTime) + (uint256(frequency) * uint256(period)) < 2 ** 32 - 1); + + // Subscription activeAt timestamp + uint32 activeAt = blockTime + period; + + // If period == 0, interval is always 1 + if (period == 0) { + uint32 actual = COORDINATOR.getSubscriptionInterval(activeAt, period); + assertEq(1, actual); + return; + } + + // Else, verify each manual interval + // blockTime -> blockTime + period = underflow (this should never be called since we verify block.timestamp >= activeAt) + // blockTime + N * period = N + uint32 expected = 1; + for (uint32 start = blockTime + period; start < (blockTime) + (frequency * period); start += period) { + // Set current time + vm.warp(start); + + // Check subscription interval + uint32 actual = COORDINATOR.getSubscriptionInterval(activeAt, period); + assertEq(expected, actual); + + // Check subscription interval 1s before if not first iteration + if (expected != 1) { + vm.warp(start - 1); + actual = COORDINATOR.getSubscriptionInterval(activeAt, period); + assertEq(expected - 1, actual); + } + + // Increment expected for next cycle + expected++; + } + } + + /// @notice Cannot deliver response for subscription that does not exist + function testCannotDeliverResponseForNonExistentSubscription() public { + // Attempt to deliver output for subscription without creating + vm.expectRevert(Coordinator.SubscriptionNotFound.selector); + ALICE.deliverCompute(1, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Cannot deliver response for non-active subscription + function testCannotDeliverResponseNonActiveSubscription() public { + // Create new subscription at time = 0 + vm.warp(0); + uint32 subId = SUBSCRIPTION.createMockSubscription( + MOCK_CONTAINER_ID, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION, + 3, + 1 minutes, + 1 + ); + + // Expect subscription to be inactive till time = 60 + vm.expectRevert(Coordinator.SubscriptionNotActive.selector); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + + // Ensure subscription is active at time = 60 + // Force failure at next conditional (gas price) + vm.txGasPrice(1 gwei + 1 wei); + vm.warp(1 minutes); + vm.expectRevert(Coordinator.GasPriceExceeded.selector); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Cannot deliver response for completed subscription + function testCannotDeliverResponseForCompletedSubscription() public { + // Create new subscription at time = 0 + vm.warp(0); + uint32 subId = SUBSCRIPTION.createMockSubscription( + MOCK_CONTAINER_ID, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION, + 2, // frequency = 2 + 1 minutes, + 1 + ); + + // Expect failure at any time prior to t = 60s + vm.warp(1 minutes - 1); + vm.expectRevert(Coordinator.SubscriptionNotActive.selector); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + + // Deliver first response at time t = 60s + vm.warp(1 minutes); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + + // Deliver second response at time t = 120s + vm.warp(2 minutes); + ALICE.deliverCompute(subId, 2, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + + // Expect revert because interval > frequency + vm.warp(3 minutes); + vm.expectRevert(Coordinator.SubscriptionCompleted.selector); + ALICE.deliverCompute(subId, 3, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Cannot deliver response if incorrect interval + function testCannotDeliverResponseIncorrectInterval() public { + // Create new subscription at time = 0 + vm.warp(0); + uint32 subId = SUBSCRIPTION.createMockSubscription( + MOCK_CONTAINER_ID, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION, + 2, // frequency = 2 + 1 minutes, + 1 + ); + + // Successfully deliver at t = 60s, interval = 1 + vm.warp(1 minutes); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + + // Unsuccesfully deliver at t = 120s, interval = 1 (expected = 2) + vm.warp(2 minutes); + vm.expectRevert(Coordinator.IntervalMismatch.selector); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Cannot deliver response delayed (after interval passed) + function testCannotDeliverResponseDelayed() public { + // Create new subscription at time = 0 + vm.warp(0); + uint32 subId = SUBSCRIPTION.createMockSubscription( + MOCK_CONTAINER_ID, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION, + 2, // frequency = 2 + 1 minutes, + 1 + ); + + // Attempt to deliver interval = 1 at time = 120s + vm.warp(2 minutes); + vm.expectRevert(Coordinator.IntervalMismatch.selector); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Cannot deliver response early (before interval arrived) + function testCannotDeliverResponseEarly() public { + // Create new subscription at time = 0 + vm.warp(0); + uint32 subId = SUBSCRIPTION.createMockSubscription( + MOCK_CONTAINER_ID, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION, + 2, // frequency = 2 + 1 minutes, + 1 + ); + + // Attempt to deliver interval = 2 at time < 120s + vm.warp(2 minutes - 1); + vm.expectRevert(Coordinator.IntervalMismatch.selector); + ALICE.deliverCompute(subId, 2, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Cannot deliver response if redundancy maxxed out + function testCannotDeliverMaxRedundancyResponse() public { + // Create new subscription at time = 0 + vm.warp(0); + uint32 subId = SUBSCRIPTION.createMockSubscription( + MOCK_CONTAINER_ID, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION, + 2, // frequency = 2 + 1 minutes, + 2 // redundancy = 2 + ); + + // Deliver from Alice + vm.warp(1 minutes); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + + // Deliver from Bob + BOB.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + + // Attempt to deliver from Charlie, expect failure + vm.expectRevert(Coordinator.IntervalCompleted.selector); + CHARLIE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Cannot deliver response if already delivered in current interval + function testCannotDeliverResponseIfAlreadyDeliveredInCurrentInterval() public { + // Create new subscription at time = 0 + vm.warp(0); + uint32 subId = SUBSCRIPTION.createMockSubscription( + MOCK_CONTAINER_ID, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION, + 2, // frequency = 2 + 1 minutes, + 2 // redundancy = 2 + ); + + // Deliver from Alice + vm.warp(1 minutes); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + + // Attempt to deliver from Alice again + vm.expectRevert(Coordinator.NodeRespondedAlready.selector); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Cannot deliver response from non-node + function testCannotDeliverResponseFromNonNode() public { + // Create new subscription at time = 0 + vm.warp(0); + uint32 subId = SUBSCRIPTION.createMockSubscription( + MOCK_CONTAINER_ID, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION, + 2, // frequency = 2 + 1 minutes, + 2 // redundancy = 2 + ); + + // Attempt to deliver from non-node + vm.expectRevert(Manager.NodeNotActive.selector); + COORDINATOR.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Cannot deliver subscription with insufficient gas limit + function testCannotDeliverSubscriptionWithInsufficientGasLimit() public { + // Create new subscription with maxGasLimit < 100 wei less than necessary + vm.warp(0); + uint32 subId = SUBSCRIPTION.createMockSubscription( + MOCK_CONTAINER_ID, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION - 100 wei, + 2, // frequency = 2 + 1 minutes, + 2 // redundancy = 2 + ); + + // Ensure that fulfilling subscription fails + vm.warp(1 minutes); + vm.expectRevert(abi.encodeWithSelector(Coordinator.GasLimitExceeded.selector)); + ALICE.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Subscription gas limit constant is approximately correct + function testSubscriptionGasLimitIsApproximatelyCorrect() public { + // Calculate approximate expected gas consumed + uint256 expectedGasConsumed = uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION; + uint256 threePercentDelta = ((expectedGasConsumed * 103) / 100) - expectedGasConsumed; + + // Create new subscription request with appropriate maxGasLimit + vm.warp(0); + uint32 subId = SUBSCRIPTION.createMockSubscription( + MOCK_CONTAINER_ID, + 1 gwei, + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()) + COLD_DELIVERY_COST_SUBSCRIPTION, + 2, // frequency = 2 + 1 minutes, + 2 // redundancy = 2 + ); + + // Deliver subscription directly as Alice and measure gas consumed + vm.warp(1 minutes); + vm.startPrank(address(ALICE)); + uint256 startingGas = gasleft(); + COORDINATOR.deliverCompute(subId, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + uint256 endingGas = gasleft(); + uint256 actualGasConsumed = startingGas - endingGas; + + // Ensure that gas consumed via direct delivery is ~approximately same as what we'd mathematically expect + assertApproxEqAbs(actualGasConsumed, expectedGasConsumed, threePercentDelta); + } +} diff --git a/test/E2E.t.sol b/test/E2E.t.sol new file mode 100644 index 0000000..778afb6 --- /dev/null +++ b/test/E2E.t.sol @@ -0,0 +1,134 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {Test} from "forge-std/Test.sol"; +import {LibStruct} from "./lib/LibStruct.sol"; +import {MockNode} from "./mocks/MockNode.sol"; +import {BalanceScale} from "./ezkl/BalanceScale.sol"; +import {DataAttestation} from "./ezkl/DataAttestor.sol"; +import {EIP712Coordinator} from "../src/EIP712Coordinator.sol"; + +/// @title BalanceScaleTest +/// @notice Tests BalanceScale E2E demo implementation +contract BalanceScaleTest is Test { + /*////////////////////////////////////////////////////////////// + INTERNAL + //////////////////////////////////////////////////////////////*/ + + /// @notice Mock node (Alice) + MockNode internal ALICE; + + /// @notice EZKL Data Attestor + DataAttestation internal ATTESTOR; + + /// @notice BalanceScale demo implementation + BalanceScale internal BALANCE_SCALE; + + /// @notice Infernet coordinator + EIP712Coordinator internal COORDINATOR; + + /*////////////////////////////////////////////////////////////// + SETUP + //////////////////////////////////////////////////////////////*/ + + function setUp() public { + // Setup coordinator + COORDINATOR = new EIP712Coordinator(); + + // Pre-predict expected address of contract(BALANCE_SCALE) + address balanceScaleAddr = 0x0F8458E544c9D4C7C25A881240727209caae20B8; + + // Setup input parameters for attestor contract + // Contract address to staticcall (our consumer contract, in this case, address(BalanceScale)) + address[] memory _contractAddresses = new address[](1); + _contractAddresses[0] = balanceScaleAddr; + + // Function calldata to get int256[4] input parameters + bytes[][] memory _calldata = new bytes[][](1); + _calldata[0] = new bytes[](4); + // We expose the current int256[4] parameters via BalanceScale.currentData + // We can simply encode the getter function for this public int256[4] state + bytes4 GETTER_SELECTOR = bytes4(keccak256("currentData(uint256)")); + for (uint8 i = 0; i < 4; i++) { + _calldata[0][i] = abi.encodeWithSelector(GETTER_SELECTOR, i); + } + + // Decimals and scaling are default set to 0 for balance scale model + uint256[][] memory _decimals = new uint256[][](1); + _decimals[0] = new uint256[](4); + uint256[] memory _scales = new uint256[](4); + for (uint8 i = 0; i < 4; i++) { + _decimals[0][i] = 0; + _scales[i] = 0; + } + + // Initialize new attestor contract with BalanceScale view-only fn parameters + ATTESTOR = new DataAttestation( + _contractAddresses, + _calldata, + _decimals, + _scales, + 0, + address(this) + ); + + // Deploy verifier contract + // Uses compiled artifacts directly from ~ROOT/out + address VERIFIER = deployCode("Verifier.sol:Halo2Verifier"); + + // Setup mock node (ALICE) and move to NodeStatus.Active + ALICE = new MockNode(COORDINATOR); + vm.warp(0); + ALICE.registerNode(address(ALICE)); + vm.warp(COORDINATOR.cooldown()); + ALICE.activateNode(); + + // Setup balance scale contract + BALANCE_SCALE = new BalanceScale( + address(COORDINATOR), + address(ATTESTOR), + VERIFIER + ); + } + + /*////////////////////////////////////////////////////////////// + TESTS + //////////////////////////////////////////////////////////////*/ + + /// @notice Test E2E flow (push inputs, initiate callback, get response, verify response) + function testE2E() public { + // Setup expected output and inputs + int256 expectedOutput = 0; // expected result is leaning left (0) + int256[4] memory inputs = [int256(1), int256(5), int256(2), int256(2)]; // inputs: [1, 5, 2, 2] + + // Setup proof (exact input to Verifier.verifyProof, including 4-byte signature) + bytes memory proof = + hex"1e8e1e130000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000096000000000000000000000000000000000000000000000000000000000000009001f2610322a656f2656716edade9f8f4f65e4ebc1acae6f01be747f65b4e7f7a01649425d0c2abea53bbe1ec30b35af753b23b008ee661506b049110fd37bdd6a2b72ada35b140c3a4a459136f8c7e9440bbb95f66636f8c8068e5d3204e92a3c1ba834aecef82f384bea9317998da017f873d95d86c587a8145a21fe900fdb47255c6109c47ad31d3e6fa005bb54887b96e2feddef6805d40089837b3a91f30d258973fa0400d78cab5bc5e2dea6618a260649283619528eaab0f76f609fc8921108cb7dc0de917ab888eb426f4d3390c9cc249f702a8dafafc6c4bdc096a92903265c413fcf6a16e4fa572c75cf8a0398615079c182c2f86ae2f4a2f6f9b40a14fd7af74b979352bf2d74d88b29f7acc78327f0b0ffc1d08147e0cb88a3ca5f2015b4c1792d908f88a2aa1095e4cb0cd95764834ea436f4e8edc45f4eb23779223773d267883beb51938377ed54f8769a83b3fdea2fb5f4544a4b26165d9b8408585beb85090fd77eb5a86de419367655bdc4358cfe1fe37ef92554eda54d9721c6b913a437e4fd2e90cb69f8f7ce9f4afbc6f974522ce9469798c4b91954871927041e25129e7024ff11836e08cac0a1ca0a628652841d12e787fe700b9ac5118213d37ce7335749108c92a0be54d80c7639a6b8565a6dc4c4908bb121c8bf29e7a431b23a833ff089cd27e9ddbbf6fe9ddb48fa22bdd54e700d9a97e31b721608654651340c32ef9bd3d42ba9051963ebce7ccbba8d1e452e57310e61c1f72e2d6777d4fc8ed7d59c32a5d4b52fe2820f7b0702d79d9a865294df6fc9020c22bdbefbfdd1e6264f163d86eab4305189644e6376dd590076eabb45bfae3a8a2f20cce3a95649073fe9106f12054ac83d694b817bcf6b571bed811f9f3c176021a56af12dd22cb147248d2130902b30bd6ef4c372519e1515996ab52e7f4d742363245ca3c7b5ba6d644131396a46174c1c77ea8757200349ca2763bd5689d42e132b6e5d2d7a548ac5d9d1d72b336684c40313b9fbd124b7596044cdb4d95e1dd99ba10afe0af4ac06a42ad4682ef4808d3319f2dee0bfc6aa5d43a8760d6b09a05745f5988c0ab42042d1f3b527abd61a0f46b73a10b6b19f4699e2f27b692b1448837a0de08eaf751a697524e5d4aa8ab34daf7b34665012ec02a4d29d4911368252e8091b10750117520515007e5eaa796499923ab4122fd093d3e2e92a2313fd6f0ded0749085c1ae71b6349232d09cbaf1c3f1d0b5b46ef38159e361a0e9bc48ceb8eb0b8ec1fa17d01e020279fb9ffcdfdadedd9a07f692871c1c3352495d2009c0e61fa2b264c9cb391860b949be3fdd096a3dc8cfe7e65a42454f31a4870c10dc76151cdcedfb04de0dc651e17f85c4995a84cb40a157ae4f6ea6d03ff483d07e8989e2a204d012a7d6b29f27ed6e7afb4b9fb3cf1b6efe8a0f6c729d591471410dbbffd312f18c26ea69d303f638ebca0393541e11622aa7c6a7606405961e062db1f56cb67829545062e1cdcff30fc9d6ba82be3b902fdc859bf16178d28fae2d800a2efc57ac0fa43784cd0dbaebb966e7fc7a898ea29d5f53d296caaa93c14285487c3000ac3512219243e0b6b391a68fdf2be8fe49d31436a1d3b314411d67128247b07c3fe7c09f1a9b24613cc346ec6df4956ea5972e9562d1ff4c476f32968532c56e16e62840456ade318d83bc3f3f08b30c7bb03b10e2d24b9b96dca54b65daf30752c803998376c4764321894b978d8960b8ceb0ce72158e0990df795372af50760aafc018e18e63483ba374abcc77b95c6745d9bb80df101d75b532ecc53cf11c477c3c6cd2396d710b5c85f9af5fc56b6e5dc2c74116f52769fe2fb7e71bd06d513681559c3477e04af04ec154fdc9c2f531d1ef526c9bd50f6d5ee0d46e361df36cd1958da82c4b4eaa002c2407448756ca3034a0987277516017519136d26f818ec037d1cbc98628f272bd6c86ceff6c41555311619a3996a90fec46c8193ebb8f72069bc5622f485db92656a7a0ba42c38000d07e21cc1ccb908cc8d6f8c7733ab61bf1641b2491ccfbf1c8d69bc8d971dd9ae23efc6f0cbf35bca881ecd70d99c76e87e775a48b318e2058d273df85b23e1662209d27eaed432e0f4721b2666fd710e6ee61b8d97a63872e0843732928e8c8e12caf63cf44d91066b28799335cd0ebf2261e8a9546afbd1abb77ae4f40470a322dd021a4c0e7ca8c968d4e9fa1a2b66cd7de5dfa220031ec88d10abc9e33a0828dd0e5f4865c9fc258f181bd9b7c572d33b4d0adc7fac1a7674b94f5f9edf35029f7e2c1c0e35f58c7efc28cc072c0bc3800db27c792e2da013d772fedab6181717b6127405d01b6dc91f473e8aaab0c17fdc4f9f02ece0e1a00c16e1a842ac1a5e0a50f4e9b24456f925dda8d28b1e90dbc825bd37959b17be81f91446792102dfea37e699ff576b865a45bd4d9573161c9594014f5566621105230ba095b904ea38680c1af826606c8c351173281f6be0cbe1bd19eea33f9edfe60a77d1c005a7758de6c2d60c233150d31172825ea5a92ed16a3c567ad40cdfabb5fdf35200ef455659e7d7d4dd2fc6ef6914480fd5880d8d0f76fe80bedaaf17516778ec2004f4831981fd6ec691632458e73860a63f602fd88bf540cc1c4b179089524507a5206b381860bcfef981d3faf3939c174f57a45033e567d56fc020471e469120e4a077270529eb7b9ace015a63e490737c741c9ba72ce0b186b91664ffdb7027db7b61f1c8e76b2f0e12b8381bcf8e212f6a411a59d0bf2cd4fc4fdf35879719c6e89f934cc972f9757f4fe0f2b6450cc7018f9251e92dcca7d0e7b5c46bff1f8fe10d734acb08c1f18c59e8eb9448bb68ea491ab2241ebf3b8c3d6ef4cfde0345ea688fb853f413570297e22eb5232ecbcb60106f3ec4b000276f07588029194575b54130cfed69fed5ce22227e94b388f38919c1a1ee00dc57749c7cea501fcfc2b838d05b1463a63e088dcef8814b1e4f687ea758d416f0e8a268e04b8d2ca956ee12faf56f1fd85af6e1f446468345749851d1024d7cab2e470f188e4305ee66c64d8ed6ef0e58a74f489b1cf01338796b4df1993bcbfd7f775649c01327ef48e58a3d98c9c0b2cf4166a4ede32ac86f2ad03dd647a1749449557a3ac01a483be7099a828fd980dd365189ef9b3509125249c423e8518eb9312d934eec177ae067117ead24cf2e888940559b2531db4bf4d9fe3175e1ab007c9167a0f400000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"; + + // Initiate prediction w/ inputs + BALANCE_SCALE.initiatePrediction(inputs); + + // Get new subscription + uint32 subscriptionId = 1; + LibStruct.Subscription memory sub = LibStruct.getSubscription(COORDINATOR, subscriptionId); + + (int256[4] memory features) = abi.decode(sub.inputs, (int256[4])); + for (uint8 i = 0; i < 4; i++) { + // Assert features are correctly stored + assertEq(inputs[i], features[i]); + // Assert inputs are correctly stored + assertEq(inputs[i], BALANCE_SCALE.data(subscriptionId, i)); + } + + // Hash recorded container input + prepare for delivery + bytes32 hashedInput = keccak256(abi.encode(inputs)); + bytes memory input = abi.encode(hashedInput); + + // Submit compute container response from Alice w/ correct proof + ALICE.deliverCompute(subscriptionId, 1, input, "really,any,response,here,we,read,true,output,from,proof", proof); + + // Assert actual output conforms to expected output + int256 actualOutput = BALANCE_SCALE.predictions(subscriptionId); + assertEq(actualOutput, expectedOutput); + } +} diff --git a/test/EIP712Coordinator.t.sol b/test/EIP712Coordinator.t.sol new file mode 100644 index 0000000..9b2811d --- /dev/null +++ b/test/EIP712Coordinator.t.sol @@ -0,0 +1,611 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {console} from "forge-std/console.sol"; +import {Test} from "forge-std/Test.sol"; +import {LibSign} from "./lib/LibSign.sol"; +import {LibStruct} from "./lib/LibStruct.sol"; +import {MockNode} from "./mocks/MockNode.sol"; +import {Coordinator} from "../src/Coordinator.sol"; +import {EIP712Coordinator} from "../src/EIP712Coordinator.sol"; +import {ICoordinatorEvents, CoordinatorConstants} from "./Coordinator.t.sol"; +import {MockDelegatorCallbackConsumer} from "./mocks/consumer/DelegatorCallback.sol"; + +/// @title EIP712CoordinatorTest +/// @notice Tests EIP712Coordinator implementation +contract EIP712CoordinatorTest is Test, CoordinatorConstants, ICoordinatorEvents { + /*////////////////////////////////////////////////////////////// + CONSTANTS + //////////////////////////////////////////////////////////////*/ + + /// @notice Cold cost of `CallbackConsumer.rawReceiveCompute` + /// @dev Inputs: (uint32, uint32, uint16, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF) + /// @dev Overriden from CoordinatorConstants since state change order forces this to cost ~100 wei more + uint32 constant CALLBACK_COST = 115_176 wei; + + /*////////////////////////////////////////////////////////////// + INTERNAL + //////////////////////////////////////////////////////////////*/ + + /// @notice EIP712Coordinator + EIP712Coordinator internal COORDINATOR; + + /// @notice Mock node (Alice) + MockNode internal ALICE; + + /// @notice Mock node (Bob) + MockNode internal BOB; + + /// @notice Mock callback consumer (w/ assigned delegatee) + MockDelegatorCallbackConsumer internal CALLBACK; + + /// @notice Delegatee address + address internal DELEGATEE_ADDRESS; + + /// @notice Delegatee private key + uint256 internal DELEGATEE_PRIVATE_KEY; + + /// @notice Backup delegatee address + address internal BACKUP_DELEGATEE_ADDRESS; + + /// @notice Backup delegatee private key + uint256 internal BACKUP_DELEGATEE_PRIVATE_KEY; + + /*////////////////////////////////////////////////////////////// + SETUP + //////////////////////////////////////////////////////////////*/ + + function setUp() public { + // Initialize coordinator + COORDINATOR = new EIP712Coordinator(); + + // Initalize mock nodes + ALICE = new MockNode(COORDINATOR); + BOB = new MockNode(COORDINATOR); + + // For each node + MockNode[2] memory nodes = [ALICE, BOB]; + for (uint256 i = 0; i < 2; i++) { + // Select node + MockNode node = nodes[i]; + + // Activate nodes + vm.warp(0); + node.registerNode(address(node)); + vm.warp(COORDINATOR.cooldown()); + node.activateNode(); + } + + // Create new delegatee + DELEGATEE_PRIVATE_KEY = 0xA11CE; + DELEGATEE_ADDRESS = vm.addr(DELEGATEE_PRIVATE_KEY); + + // Create new backup delegatee + BACKUP_DELEGATEE_PRIVATE_KEY = 0xB0B; + BACKUP_DELEGATEE_ADDRESS = vm.addr(BACKUP_DELEGATEE_PRIVATE_KEY); + + // Initialize mock callback consumer w/ assigned delegate + CALLBACK = new MockDelegatorCallbackConsumer( + address(COORDINATOR), + DELEGATEE_ADDRESS + ); + } + + /*////////////////////////////////////////////////////////////// + UTILITY FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Creates new mock subscription with sane defaults + function getMockSubscription() public view returns (Coordinator.Subscription memory) { + return Coordinator.Subscription({ + activeAt: uint32(block.timestamp), + owner: address(CALLBACK), + maxGasPrice: 1 gwei, + redundancy: 1, + maxGasLimit: CALLBACK_COST + uint32(COORDINATOR.DELEGATEE_OVERHEAD_CREATE_WEI()) + + uint32(COORDINATOR.DELIVERY_OVERHEAD_WEI()), + frequency: 1, + period: 0, + containerId: MOCK_CONTAINER_ID, + inputs: MOCK_CONTAINER_INPUTS + }); + } + + /// @notice Generates the hash of the fully encoded EIP-712 message, based on environment domain config + /// @param nonce subscriber contract nonce + /// @param expiry signature expiry + /// @param sub subscription + /// @return typed EIP-712 message hash + function getMessage(uint32 nonce, uint32 expiry, Coordinator.Subscription memory sub) + public + view + returns (bytes32) + { + return LibSign.getTypedMessageHash( + COORDINATOR.EIP712_NAME(), COORDINATOR.EIP712_VERSION(), address(COORDINATOR), nonce, expiry, sub + ); + } + + /// @notice Mocks subscription creation via EIP712 delegate process + /// @param nonce subscriber contract nonce + /// @return subscriptionId + function createMockSubscriptionEIP712(uint32 nonce) public returns (uint32) { + // Check initial subscriptionId + uint32 id = COORDINATOR.id(); + + // Create new dummy subscription + Coordinator.Subscription memory sub = getMockSubscription(); + + // Check max subscriber nonce + uint32 maxSubscriberNonce = COORDINATOR.maxSubscriberNonce(sub.owner); + + // Generate signature expiry + uint32 expiry = uint32(block.timestamp) + 30 minutes; + + // Get EIP-712 typed message + bytes32 message = getMessage(nonce, expiry, sub); + + // Sign message from delegatee private key + (uint8 v, bytes32 r, bytes32 s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + + // Create subscription + (uint32 subscriptionId,) = COORDINATOR.createSubscriptionDelegatee(0, expiry, sub, v, r, s); + assertEq(subscriptionId, id); + + // Assert subscription data is correctly stored + LibStruct.Subscription memory actual = LibStruct.getSubscription(COORDINATOR, id); + assertEq(sub.activeAt, actual.activeAt); + assertEq(sub.owner, actual.owner); + assertEq(sub.maxGasPrice, actual.maxGasPrice); + assertEq(sub.redundancy, actual.redundancy); + assertEq(sub.maxGasLimit, actual.maxGasLimit); + assertEq(sub.frequency, actual.frequency); + assertEq(sub.period, actual.period); + assertEq(sub.containerId, actual.containerId); + assertEq(sub.inputs, actual.inputs); + + // Assert state is correctly updated + if (nonce > maxSubscriberNonce) { + assertEq(COORDINATOR.maxSubscriberNonce(address(CALLBACK)), nonce); + } else { + assertEq(COORDINATOR.maxSubscriberNonce(address(CALLBACK)), maxSubscriberNonce); + } + assertEq(COORDINATOR.delegateCreatedIds(keccak256(abi.encode(address(CALLBACK), nonce))), subscriptionId); + + // Explicitly return new subscriptionId + return subscriptionId; + } + + /*////////////////////////////////////////////////////////////// + TESTS + //////////////////////////////////////////////////////////////*/ + + function testCannotCreateDelegatedSubscriptionWhereSignatureExpired() public { + // Create new dummy subscription + Coordinator.Subscription memory sub = getMockSubscription(); + + // Generate signature expiry + uint32 expiry = uint32(block.timestamp) + 30 minutes; + + // Get EIP-712 typed message + bytes32 message = getMessage(0, expiry, sub); + + // Sign message from delegatee private key + (uint8 v, bytes32 r, bytes32 s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + + // Warp time forward past signature expiry + vm.warp(expiry + 1 seconds); + + // Create subscription via delegate and expect error + vm.expectRevert(EIP712Coordinator.SignatureExpired.selector); + COORDINATOR.createSubscriptionDelegatee(0, expiry, sub, v, r, s); + } + + /// @notice Cannot create delegated subscription where signature does not match + function testFuzzCannotCreateDelegatedSubscriptionWhereSignatureMismatch(uint256 privateKey) public { + // Ensure signer private key is not actual delegatee private key + vm.assume(privateKey != DELEGATEE_PRIVATE_KEY); + // Ensure signer private key < secp256k1 curve order + vm.assume(privateKey < SECP256K1_ORDER); + // Ensure signer private key != 0 + vm.assume(privateKey != 0); + + // Create new dummy subscription + Coordinator.Subscription memory sub = getMockSubscription(); + + // Generate signature expiry + uint32 expiry = uint32(block.timestamp) + 30 minutes; + + // Get EIP-712 typed message + bytes32 message = getMessage(0, expiry, sub); + + // Sign message from new private key + (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, message); + + // Create subscription via delegate and expect error + vm.expectRevert(EIP712Coordinator.SignerMismatch.selector); + COORDINATOR.createSubscriptionDelegatee(0, expiry, sub, v, r, s); + } + + /// @notice Can create new subscription via EIP712 signature + function testCanCreateNewSubscriptionViaEIP712() public { + // Create new dummy subscription + Coordinator.Subscription memory sub = getMockSubscription(); + + // Generate signature expiry + uint32 expiry = uint32(block.timestamp) + 30 minutes; + + // Get EIP-712 typed message + bytes32 message = getMessage(0, expiry, sub); + + // Sign message from delegatee private key + (uint8 v, bytes32 r, bytes32 s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + + // Create subscription + (uint32 subscriptionId,) = COORDINATOR.createSubscriptionDelegatee(0, expiry, sub, v, r, s); + assertEq(subscriptionId, 1); + + // Assert subscription data is correctly stored + LibStruct.Subscription memory actual = LibStruct.getSubscription(COORDINATOR, 1); + assertEq(sub.activeAt, actual.activeAt); + assertEq(sub.owner, actual.owner); + assertEq(sub.maxGasPrice, actual.maxGasPrice); + assertEq(sub.redundancy, actual.redundancy); + assertEq(sub.maxGasLimit, actual.maxGasLimit); + assertEq(sub.frequency, actual.frequency); + assertEq(sub.period, actual.period); + assertEq(sub.containerId, actual.containerId); + assertEq(sub.inputs, actual.inputs); + + // Assert state is correctly updated + assertEq(COORDINATOR.maxSubscriberNonce(address(CALLBACK)), 0); + assertEq(COORDINATOR.delegateCreatedIds(keccak256(abi.encode(address(CALLBACK), uint32(0)))), 1); + } + + /// @notice Cannot use valid delegated subscription from old signer + function testCannotUseValidDelegatedSubscriptionFromOldSigner() public { + // Create new dummy subscription + Coordinator.Subscription memory sub = getMockSubscription(); + + // Generate signature expiry + uint32 expiry = uint32(block.timestamp) + 30 minutes; + + // Get EIP-712 typed message + bytes32 message = getMessage(0, expiry, sub); + + // Sign message from delegatee private key + (uint8 v, bytes32 r, bytes32 s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + + // Update signer to backup delegatee + CALLBACK.updateMockSigner(BACKUP_DELEGATEE_ADDRESS); + + // Create subscription with valid message and expect error + vm.expectRevert(EIP712Coordinator.SignerMismatch.selector); + COORDINATOR.createSubscriptionDelegatee(0, expiry, sub, v, r, s); + } + + /// @notice Can use existing subscription created by old signer + function testCanUseExistingDelegatedSubscriptionFromOldSigner() public { + // Create new dummy subscription + Coordinator.Subscription memory sub = getMockSubscription(); + + // Generate signature expiry + uint32 expiry = uint32(block.timestamp) + 30 minutes; + + // Get EIP-712 typed message + bytes32 message = getMessage(0, expiry, sub); + + // Sign message from delegatee private key + (uint8 v, bytes32 r, bytes32 s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + + // Create subscription + (uint32 subscriptionId,) = COORDINATOR.createSubscriptionDelegatee(0, expiry, sub, v, r, s); + assertEq(subscriptionId, 1); + + // Update signer to backup delegatee + CALLBACK.updateMockSigner(BACKUP_DELEGATEE_ADDRESS); + + // Creating subscription should return existing subscription (ID: 1) + (subscriptionId,) = COORDINATOR.createSubscriptionDelegatee(0, expiry, sub, v, r, s); + assertEq(subscriptionId, 1); + } + + /// @notice Cannot create delegated subscription where nonce is reused + function testCannotCreateDelegatedSubscriptionWhereNonceReused() public { + // Setup nonce + uint32 nonce = 0; + + // Create new dummy subscription + Coordinator.Subscription memory sub = getMockSubscription(); + + // Generate signature expiry + uint32 expiry = uint32(block.timestamp) + 30 minutes; + + // Get EIP-712 typed message + bytes32 message = getMessage(nonce, expiry, sub); + + // Sign message + (uint8 v, bytes32 r, bytes32 s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + + // Create subscription + (uint32 subscriptionId,) = COORDINATOR.createSubscriptionDelegatee(nonce, expiry, sub, v, r, s); + assertEq(subscriptionId, 1); + + // Create second dummy subscription and set redundancy to 5 (identifier param) + sub = getMockSubscription(); + uint16 oldRedundancy = sub.redundancy; + sub.redundancy = 5; + + // Get EIP-712 typed message + message = getMessage(nonce, expiry, sub); + + // Sign message + (v, r, s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + + // Create subscription (notice, with the same nonce) + (subscriptionId,) = COORDINATOR.createSubscriptionDelegatee(nonce, expiry, sub, v, r, s); + + // Assert that we are instead simply returned the existing subscription + assertEq(subscriptionId, 1); + // Also, assert that the redundancy has not changed + LibStruct.Subscription memory actual = LibStruct.getSubscription(COORDINATOR, subscriptionId); + assertEq(actual.redundancy, oldRedundancy); + + // Now, ensure that we can't resign with a new delegatee and force nonce replay + // Change the signing delegatee to the backup delegatee + CALLBACK.updateMockSigner(BACKUP_DELEGATEE_ADDRESS); + + // Use same summy subscription with redundancy == 5, but sign with backup delegatee + (v, r, s) = vm.sign(BACKUP_DELEGATEE_PRIVATE_KEY, message); + + // Create subscription (notice, with the same nonce) + (subscriptionId,) = COORDINATOR.createSubscriptionDelegatee(nonce, expiry, sub, v, r, s); + + // Assert that we are instead simply returned the existing subscription + assertEq(subscriptionId, 1); + // Also, assert that the redundancy has not changed + actual = LibStruct.getSubscription(COORDINATOR, subscriptionId); + assertEq(actual.redundancy, oldRedundancy); + } + + /// @notice Can create delegated subscription with out of order nonces + function testCanCreateDelegatedSubscriptionWithUnorderedNonces() public { + // Create subscription with nonce 10 + uint32 nonce = 10; + Coordinator.Subscription memory sub = getMockSubscription(); + uint32 expiry = uint32(block.timestamp) + 30 minutes; + bytes32 message = getMessage(nonce, expiry, sub); + (uint8 v, bytes32 r, bytes32 s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + (uint32 subscriptionId,) = COORDINATOR.createSubscriptionDelegatee(nonce, expiry, sub, v, r, s); + assertEq(subscriptionId, 1); + + // Ensure maximum subscriber nonce is 10 + assertEq(COORDINATOR.maxSubscriberNonce(sub.owner), 10); + + // Create subscription with nonce 1 + nonce = 1; + sub = getMockSubscription(); + expiry = uint32(block.timestamp) + 30 minutes; + message = getMessage(nonce, expiry, sub); + (v, r, s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + (subscriptionId,) = COORDINATOR.createSubscriptionDelegatee(nonce, expiry, sub, v, r, s); + assertEq(subscriptionId, 2); + + // Ensure maximum subscriber nonce is still 10 + assertEq(COORDINATOR.maxSubscriberNonce(sub.owner), 10); + + // Attempt to replay tx with nonce 10 + nonce = 10; + sub = getMockSubscription(); + expiry = uint32(block.timestamp) + 30 minutes; + message = getMessage(nonce, expiry, sub); + (v, r, s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + (subscriptionId,) = COORDINATOR.createSubscriptionDelegatee(nonce, expiry, sub, v, r, s); + + // Ensure that instead of a new subscription, existing subscription (ID: 1) is returned + assertEq(subscriptionId, 1); + } + + /// @notice Can get existing subscription via `createDelegateSubscription` + /// @dev Also tests for preventing signature replay + function testCanGetExistingSubscriptionViaEIP712() public { + // Create mock subscription via delegate, nonce 0 + uint32 subscriptionId = createMockSubscriptionEIP712(0); + + // Immediately collect subscriptionId without any signature verifications + (uint32 expectedSubscriptionId,) = + COORDINATOR.createSubscriptionDelegatee(0, 0, getMockSubscription(), 0, "", ""); + assertEq(subscriptionId, expectedSubscriptionId); + } + + /// @notice Can cancel subscription created via delegate + function testCanCancelSubscriptionCreatedViaDelegate() public { + // Create mock subscription via delegate, nonce 0 + uint32 subscriptionId = createMockSubscriptionEIP712(0); + + // Attempt to cancel from Callback contract + vm.startPrank(address(CALLBACK)); + COORDINATOR.cancelSubscription(subscriptionId); + + // Assert cancelled status + LibStruct.Subscription memory actual = LibStruct.getSubscription(COORDINATOR, 1); + assertEq(actual.owner, address(0)); + } + + /// @notice Can delegated deliver compute reponse, while creating new subscription + function testCanAtomicCreateSubscriptionAndDeliverOutput() public { + // Starting nonce + uint32 nonce = COORDINATOR.maxSubscriberNonce(address(CALLBACK)); + + // Create new dummy subscription + Coordinator.Subscription memory sub = getMockSubscription(); + + // Generate signature expiry + uint32 expiry = uint32(block.timestamp) + 30 minutes; + + // Get EIP-712 typed message + bytes32 message = getMessage(nonce, expiry, sub); + + // Sign message from delegatee private key + (uint8 v, bytes32 r, bytes32 s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + + // Create subscription and deliver response, via deliverComputeDelegatee + uint32 subscriptionId = 1; + uint32 deliveryInterval = 1; + ALICE.deliverComputeDelegatee( + nonce, expiry, sub, v, r, s, deliveryInterval, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF + ); + + // Get response + LibStruct.DeliveredOutput memory out = + LibStruct.getDeliveredOutput(CALLBACK, subscriptionId, deliveryInterval, 1); + assertEq(out.subscriptionId, subscriptionId); + assertEq(out.interval, deliveryInterval); + assertEq(out.redundancy, 1); + assertEq(out.input, MOCK_INPUT); + assertEq(out.output, MOCK_OUTPUT); + assertEq(out.proof, MOCK_PROOF); + + // Ensure subscription completion is tracked + bytes32 key = keccak256(abi.encode(subscriptionId, deliveryInterval, address(ALICE))); + assertEq(COORDINATOR.nodeResponded(key), true); + } + + /// @notice Cannot delegated deliver compute response for completed subscription + function testCannotAtomicDeliverOutputForCompletedSubscription() public { + // Starting nonce + uint32 nonce = COORDINATOR.maxSubscriberNonce(address(CALLBACK)); + + // Create new dummy subscription + Coordinator.Subscription memory sub = getMockSubscription(); + + // Generate signature expiry + uint32 expiry = uint32(block.timestamp) + 30 minutes; + + // Get EIP-712 typed message + bytes32 message = getMessage(nonce, expiry, sub); + + // Sign message from delegatee private key + (uint8 v, bytes32 r, bytes32 s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + + // Create subscription and deliver response, via deliverComputeDelegatee + uint32 subscriptionId = 1; + uint32 deliveryInterval = 1; + ALICE.deliverComputeDelegatee( + nonce, expiry, sub, v, r, s, deliveryInterval, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF + ); + + // Attempt to deliver from Bob via delegatee + vm.expectRevert(Coordinator.IntervalCompleted.selector); + BOB.deliverComputeDelegatee(nonce, expiry, sub, v, r, s, deliveryInterval, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + + // Attempt to delivery from Bob direct + vm.expectRevert(Coordinator.IntervalCompleted.selector); + BOB.deliverCompute(subscriptionId, deliveryInterval, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Can delegated deliver compute response for existing subscription + function testCanDelegatedDeliverComputeResponseForExistingSubscription() public { + // Starting nonce + uint32 nonce = COORDINATOR.maxSubscriberNonce(address(CALLBACK)); + + // Create new dummy subscription + Coordinator.Subscription memory sub = getMockSubscription(); + // Modify dummy subscription to allow > 1 redundancy + sub.redundancy = 2; + + // Generate signature expiry + uint32 expiry = uint32(block.timestamp) + 30 minutes; + + // Get EIP-712 typed message + bytes32 message = getMessage(nonce, expiry, sub); + + // Sign message from delegatee private key + (uint8 v, bytes32 r, bytes32 s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + + // Delivery from Alice + uint32 subscriptionId = 1; + uint32 deliveryInterval = 1; + ALICE.deliverComputeDelegatee( + nonce, expiry, sub, v, r, s, deliveryInterval, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF + ); + + // Ensure subscription completion is tracked + bytes32 key = keccak256(abi.encode(subscriptionId, deliveryInterval, address(ALICE))); + assertEq(COORDINATOR.nodeResponded(key), true); + + // Deliver from Bob + BOB.deliverComputeDelegatee(nonce, expiry, sub, v, r, s, deliveryInterval, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + + // Ensure subscription completion is tracked + key = keccak256(abi.encode(subscriptionId, deliveryInterval, address(BOB))); + assertEq(COORDINATOR.nodeResponded(key), true); + + // Expect revert if trying to deliver again + vm.expectRevert(Coordinator.IntervalCompleted.selector); + BOB.deliverComputeDelegatee(nonce, expiry, sub, v, r, s, deliveryInterval, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Cannot deliver subscription where gas limit is too low + function testCannotDeliverEIP712SubscriptionWhereGasLimitTooLow() public { + // Starting nonce + uint32 nonce = COORDINATOR.maxSubscriberNonce(address(CALLBACK)); + + // Create new dummy subscription + Coordinator.Subscription memory sub = getMockSubscription(); + + // Purposefully reduce gasLimit of subscription down ~200 gwei + sub.maxGasLimit -= 200; + + // Generate signature expiry + uint32 expiry = uint32(block.timestamp) + 30 minutes; + + // Get EIP-712 typed message + bytes32 message = getMessage(nonce, expiry, sub); + + // Sign message from delegatee private key + (uint8 v, bytes32 r, bytes32 s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + + // Create subscription and deliver response, expecting an out of gas revert + vm.expectRevert(abi.encodeWithSelector(Coordinator.GasLimitExceeded.selector)); + ALICE.deliverComputeDelegatee(nonce, expiry, sub, v, r, s, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + } + + /// @notice Can deliver compute response for already created subscription with reduced gas limit + function testDeliverReducedGasCostSubscriptionCachedSubscription() public { + // Create new subscription with redundancy = 2 + Coordinator.Subscription memory sub = getMockSubscription(); + sub.redundancy = 2; + + // Generate signature expiry + uint32 expiry = uint32(block.timestamp) + 30 minutes; + + // Get signed data + uint32 nonce = COORDINATOR.maxSubscriberNonce(address(CALLBACK)); + bytes32 message = getMessage(nonce, expiry, sub); + (uint8 v, bytes32 r, bytes32 s) = vm.sign(DELEGATEE_PRIVATE_KEY, message); + + // Manually verifying the callstack is useful here to ensure that the overhead gas is being properly set + // Measure direct delivery for creation + delivery + uint256 inputOverhead = 35_000 wei; + uint256 gasExpected = CALLBACK_COST + COORDINATOR.DELEGATEE_OVERHEAD_CREATE_WEI() + + COORDINATOR.DELIVERY_OVERHEAD_WEI() + inputOverhead; + uint256 startingGas = gasleft(); + ALICE.deliverComputeDelegatee(nonce, expiry, sub, v, r, s, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + uint256 endingGas = gasleft(); + uint256 gasUsed = startingGas - endingGas; + + // Measure direct delivery for cached creation + delivery + uint256 gasExpectedCached = + CALLBACK_COST + COORDINATOR.DELEGATEE_OVERHEAD_CACHED_WEI() + COORDINATOR.DELIVERY_OVERHEAD_WEI(); + startingGas = gasleft(); + BOB.deliverComputeDelegatee(nonce, expiry, sub, v, r, s, 1, MOCK_INPUT, MOCK_OUTPUT, MOCK_PROOF); + endingGas = gasleft(); + uint256 gasUsedCached = startingGas - endingGas; + + // Assert in ~approximate range (+/- 15K gas, actually copying calldata into memory is expensive) + uint256 delta = 15_000 wei; + assertApproxEqAbs(gasExpected, gasUsed, delta); + assertApproxEqAbs(gasExpectedCached, gasUsedCached, delta); + } +} diff --git a/test/Manager.t.sol b/test/Manager.t.sol new file mode 100644 index 0000000..a9d288c --- /dev/null +++ b/test/Manager.t.sol @@ -0,0 +1,306 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {Test} from "forge-std/Test.sol"; +import {Manager} from "../src/Manager.sol"; +import {MockNode} from "./mocks/MockNode.sol"; +import {Ownable} from "solady/auth/Ownable.sol"; +import {MockManager} from "./mocks/MockManager.sol"; +import {EIP712Coordinator} from "../src/EIP712Coordinator.sol"; + +/// @title IManagerEvents +/// @notice Events emitted by Manager +interface IManagerEvents { + event NodeActivated(address indexed node); + event NodeDeactivated(address indexed node); + event NodeRegistered(address indexed node, address indexed registerer, uint32 cooldownStart); +} + +/// @title ManagerTest +/// @notice Tests Manager implementation +contract ManagerTest is Test, IManagerEvents { + /*////////////////////////////////////////////////////////////// + INTERNAL + //////////////////////////////////////////////////////////////*/ + + /// @notice Manager + MockManager internal MANAGER; + + /// @notice Mock node (Alice) + MockNode internal ALICE; + + /// @notice Mock node (Bob) + MockNode internal BOB; + + /*////////////////////////////////////////////////////////////// + SETUP + //////////////////////////////////////////////////////////////*/ + + function setUp() public { + // Initialize manager + MANAGER = new MockManager(); + + // Initialize mock nodes + // Overriding manager to parent type of EIP712Coordinator + ALICE = new MockNode(EIP712Coordinator(address(MANAGER))); + BOB = new MockNode(EIP712Coordinator(address(MANAGER))); + } + + /*////////////////////////////////////////////////////////////// + TESTS + //////////////////////////////////////////////////////////////*/ + + /// @notice Check can register inactive node + function testCanRegisterInactiveNode() public { + uint256 startTimestamp = 10 minutes; + vm.warp(startTimestamp); + + // Make calls as Alice + address aliceAddress = address(ALICE); + vm.startPrank(aliceAddress); + + // Ensure starting cooldown is at timestamp 0 + assertEq(ALICE.cooldownStart(), 0); + assertEq(BOB.cooldownStart(), 0); + + // Register Alice by self + vm.expectEmit(address(MANAGER)); + emit NodeRegistered(aliceAddress, aliceAddress, uint32(startTimestamp)); + MANAGER.registerNode(aliceAddress); + + // Check new node statuses + ALICE.assertNodeStatus(Manager.NodeStatus.Registered); + BOB.assertNodeStatus(Manager.NodeStatus.Inactive); + + // Check cooldown start timestamps + assertEq(ALICE.cooldownStart(), startTimestamp); + assertEq(BOB.cooldownStart(), 0); + } + + /// @notice Check can register inactive node via proxy + function testCanRegisterInactiveNodeViaProxy() public { + uint256 startTimestamp = 10 minutes; + vm.warp(startTimestamp); + + // Make calls as Bob + address bobAddress = address(BOB); + address aliceAddress = address(ALICE); + vm.startPrank(bobAddress); + + // Ensure starting cooldown is at timestamp 0 + assertEq(ALICE.cooldownStart(), 0); + assertEq(BOB.cooldownStart(), 0); + + // Register Alice with Bob as registrar + vm.expectEmit(address(MANAGER)); + emit NodeRegistered(aliceAddress, bobAddress, uint32(startTimestamp)); + MANAGER.registerNode(aliceAddress); + + // Check new node statuses + ALICE.assertNodeStatus(Manager.NodeStatus.Registered); + BOB.assertNodeStatus(Manager.NodeStatus.Inactive); + + // Check cooldown start timestamps + assertEq(ALICE.cooldownStart(), startTimestamp); + assertEq(BOB.cooldownStart(), 0); + } + + /// @notice Check registered node cannot re-register + function testCannotReregisterNode() public { + // Register Alice + ALICE.registerNode(address(ALICE)); + ALICE.assertNodeStatus(Manager.NodeStatus.Registered); + + // Ensure revert if trying to register again + vm.expectRevert( + abi.encodeWithSelector( + Manager.NodeNotRegisterable.selector, address(ALICE), uint8(Manager.NodeStatus.Registered) + ) + ); + ALICE.registerNode(address(ALICE)); + } + + /// @notice Check cannot register node if node is Active + function testCannotRegisterActiveNode() public { + // Register Alice + ALICE.registerNode(address(ALICE)); + + vm.warp(block.timestamp + MANAGER.cooldown()); + // Activate Alice + ALICE.activateNode(); + + // Ensure revert if trying to register + vm.expectRevert( + abi.encodeWithSelector( + Manager.NodeNotRegisterable.selector, address(ALICE), uint8(Manager.NodeStatus.Active) + ) + ); + ALICE.registerNode(address(ALICE)); + } + + /// @notice Check can activate a node + function testActivateNode() public { + uint256 startTimestamp = 10 minutes; + vm.warp(startTimestamp); + + // Register Alice + ALICE.registerNode(address(ALICE)); + + vm.warp(startTimestamp + MANAGER.cooldown()); + // Activate Alice + vm.expectEmit(address(MANAGER)); + emit NodeActivated(address(ALICE)); + ALICE.activateNode(); + + // Check states + assertEq(ALICE.isActiveNode(), true); + assertEq(ALICE.cooldownStart(), 0); + ALICE.assertNodeStatus(Manager.NodeStatus.Active); + } + + /// @notice Check cannot activate node before cooldown has elapsed + function testFuzzCannotActivateNodeBeforeCooldownElapsed(uint256 elapsed) public { + uint256 startTimestamp = 10 minutes; + vm.warp(startTimestamp); + + // Force elapsed to be under cooldown + vm.assume(elapsed < MANAGER.cooldown()); + + // Register Alice + ALICE.registerNode(address(ALICE)); + + vm.warp(startTimestamp + elapsed); + // Ensure revert when attempting to activate Alice + vm.expectRevert(abi.encodeWithSelector(Manager.CooldownActive.selector, startTimestamp)); + ALICE.activateNode(); + } + + /// @notice Check cannot activate node if node is inactive + function testCannotActivateInactiveNode() public { + // Attempt to activate without registering + vm.expectRevert( + abi.encodeWithSelector(Manager.NodeNotActivateable.selector, uint8(Manager.NodeStatus.Inactive)) + ); + ALICE.activateNode(); + } + + /// @notice Check cannot re-activate node + function testCannotReactivateNode() public { + // Activate Alice + ALICE.registerNode(address(ALICE)); + vm.warp(block.timestamp + MANAGER.cooldown()); + ALICE.activateNode(); + + // Attempt to re-activate Alice + vm.expectRevert(abi.encodeWithSelector(Manager.NodeNotActivateable.selector, uint8(Manager.NodeStatus.Active))); + ALICE.activateNode(); + } + + /// @notice Check that active nodes can call onlyActiveNode functions + function testCanCallOnlyActiveNodeFnAsActiveNode() public { + // Activate Alice + ALICE.registerNode(address(ALICE)); + vm.warp(block.timestamp + MANAGER.cooldown()); + ALICE.activateNode(); + + // Attempt to call onlyActiveNode-modified function + assertEq(ALICE.isActiveNode(), true); + } + + /// @notice Check inactive nodes cannot call onlyActiveNode functions + function testCannnotCallOnlyActiveNodeFnAsInactiveNode() public { + vm.expectRevert(Manager.NodeNotActive.selector); + ALICE.isActiveNode(); + } + + /// @notice Check registered nodes cannot call onlyActiveNode functions + function testCannotCallOnlyActiveNodeFnAsRegisteredNode() public { + ALICE.registerNode(address(ALICE)); + vm.expectRevert(Manager.NodeNotActive.selector); + ALICE.isActiveNode(); + } + + /// @notice Check that node can go to an inactive state from inactive + function testCanDeactivateInactiveNode() public { + ALICE.assertNodeStatus(Manager.NodeStatus.Inactive); + vm.expectEmit(address(MANAGER)); + emit NodeDeactivated(address(ALICE)); + ALICE.deactivateNode(); + ALICE.assertNodeStatus(Manager.NodeStatus.Inactive); + } + + /// @notice Check that node can go to an inactive state from registered + function testCanDeactivateRegisteredNode() public { + // Register Alice + ALICE.registerNode(address(ALICE)); + ALICE.assertNodeStatus(Manager.NodeStatus.Registered); + + // Deactive Alice + vm.expectEmit(address(MANAGER)); + emit NodeDeactivated(address(ALICE)); + ALICE.deactivateNode(); + ALICE.assertNodeStatus(Manager.NodeStatus.Inactive); + } + + /// @notice Check that node can go to an inactive state from Active + function testCanDeactivateActiveNode() public { + // Activate Alice + ALICE.registerNode(address(ALICE)); + vm.warp(block.timestamp + MANAGER.cooldown()); + ALICE.activateNode(); + + // Deactivate node + vm.expectEmit(address(MANAGER)); + emit NodeDeactivated(address(ALICE)); + ALICE.deactivateNode(); + ALICE.assertNodeStatus(Manager.NodeStatus.Inactive); + } + + function testActivateNodeMustReadministerCooldownIfReactivating() public { + uint256 startTimestamp = 10 minutes; + vm.warp(startTimestamp); + + // Register Alice + ALICE.registerNode(address(ALICE)); + + // Assert Alice status and cooldown + ALICE.assertNodeStatus(Manager.NodeStatus.Registered); + assertEq(ALICE.cooldownStart(), startTimestamp); + + vm.warp(startTimestamp + MANAGER.cooldown()); + // Activate Alice + ALICE.activateNode(); + + // Assert Alice status and nullifed cooldown + ALICE.assertNodeStatus(Manager.NodeStatus.Active); + assertEq(ALICE.cooldownStart(), 0); + + // Deactive Alice + ALICE.deactivateNode(); + + // Assert Alice status and nullified cooldown + ALICE.assertNodeStatus(Manager.NodeStatus.Inactive); + assertEq(ALICE.cooldownStart(), 0); + + // Re-register Alice + ALICE.registerNode(address(ALICE)); + + // Assert Alice status and new cooldown + ALICE.assertNodeStatus(Manager.NodeStatus.Registered); + uint256 newCooldownStart = startTimestamp + MANAGER.cooldown(); + assertEq(ALICE.cooldownStart(), newCooldownStart); + + // Expect re-activation to fail if not administering full cooldown + vm.warp(newCooldownStart + MANAGER.cooldown() - 1 seconds); + vm.expectRevert(abi.encodeWithSelector(Manager.CooldownActive.selector, newCooldownStart)); + ALICE.activateNode(); + + // Expect re-activation to succeed if complying with new cooldown + vm.warp(newCooldownStart + MANAGER.cooldown()); + ALICE.activateNode(); + + // Assert Alice status and new cooldown + ALICE.assertNodeStatus(Manager.NodeStatus.Active); + assertEq(ALICE.cooldownStart(), 0); + } +} diff --git a/test/ezkl/BalanceScale.sol b/test/ezkl/BalanceScale.sol new file mode 100644 index 0000000..52bbb39 --- /dev/null +++ b/test/ezkl/BalanceScale.sol @@ -0,0 +1,117 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {DataAttestation} from "./DataAttestor.sol"; +import {CallbackConsumer} from "../../src/consumer/Callback.sol"; + +/// @title BalanceScale +/// @notice E2E developer demo of a balance scale prediction contract +/// @dev Uses simple model trained on UCI balance scale data: https://archive.ics.uci.edu/dataset/12/balance+scale +contract BalanceScale is CallbackConsumer { + /*////////////////////////////////////////////////////////////// + IMMUTABLE + //////////////////////////////////////////////////////////////*/ + + /// @notice EZKL verifier contract address + address internal immutable VERIFIER; + + /// @notice EZKL attestor contract + DataAttestation internal immutable ATTESTOR; + + /*////////////////////////////////////////////////////////////// + MUTABLE + //////////////////////////////////////////////////////////////*/ + + /// @notice Data currently being verified + /// @dev Used atomically in `_receiveCompute()` callback to remove need for dynamic loading in attestor contract + int256[4] public currentData; + + /// @notice Subscription ID => associated balance scale weights + /// @dev format: [right-distance, right-weight, left-distance, left-weight] + mapping(uint32 => int256[4]) public data; + + /// @notice SubscriptionID => returned prediction output + /// @dev 0 = scale tipped left, 1 = scale tipped right, 2 = balanced + mapping(uint32 => int256) public predictions; + + /*////////////////////////////////////////////////////////////// + ERRORS + //////////////////////////////////////////////////////////////*/ + + /// @notice Thrown if inputs to compute container are recorded incorrectly + /// @dev 4-byte signature `0x6364fc0e` + error InputsIncorrect(); + + /// @notice Thrown if proof verification fails + /// @dev 4-byte signature `0xd30ec238` + error ProofIncorrect(); + + /*////////////////////////////////////////////////////////////// + CONSTRUCTOR + //////////////////////////////////////////////////////////////*/ + + /// @notice Initialize new BalanceScale + /// @param coordinator coordinator address + /// @param attestor EZKL attestor address + /// @param verifier EZKL verifier address + constructor(address coordinator, address attestor, address verifier) CallbackConsumer(coordinator) { + // Initiate attestor contract + ATTESTOR = DataAttestation(attestor); + // Set verifier address + VERIFIER = verifier; + } + + /*////////////////////////////////////////////////////////////// + FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Initiates new prediction by encoding input parameters and kicking off compute request callback + /// @param input balance scale params: [right-distance, right-weight, left-distance, left-weight] + function initiatePrediction(int256[4] calldata input) external { + // Encode features + bytes memory features = abi.encode(input); + + // Make new callback request + uint32 id = _requestCompute("BSM", features, 1000 gwei, 1_000_000 wei, 1); + + // Store input data + data[id] = input; + } + + /// @notice Inherited function: CallbackConsumer._receiveCompute + function _receiveCompute( + uint32 subscriptionId, + uint32 interval, + uint16 redundancy, + address node, + bytes calldata input, + bytes calldata output, + bytes calldata proof + ) internal override { + // On callback, first, set currentData = relevant data to verify for subscription + currentData = data[subscriptionId]; + + // Verify off-chain recorded input is correct + bytes32 hashedInput = keccak256(abi.encode(currentData)); + (bytes32 recordedInput) = abi.decode(input, (bytes32)); + if (hashedInput != recordedInput) { + revert InputsIncorrect(); + } + + // Attest + verify proof via attestor + bool verified = ATTESTOR.verifyWithDataAttestation(VERIFIER, proof); + + // Error if proof not verified + if (!verified) { + revert ProofIncorrect(); + } + + // Proof begins with 4-byte signature to Verifier (because Verifier is staticall'd from Attestor) + // Thus, we first strip the first 4-bytes of proof to collect just function data + // Then, we decode the instances array from the stripped proof + (, uint256[] memory instances) = abi.decode(proof[4:proof.length], (bytes, uint256[])); + + // Set prediction to predicted result from instances array + predictions[subscriptionId] = int256(instances[instances.length - 1]); + } +} diff --git a/test/ezkl/DataAttestor.sol b/test/ezkl/DataAttestor.sol new file mode 100644 index 0000000..d355f1b --- /dev/null +++ b/test/ezkl/DataAttestor.sol @@ -0,0 +1,273 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.19; + +// This contract serves as a Data Attestation Verifier for the EZKL model. +// It is designed to read and attest to instances of proofs generated from a specified circuit. +// It is particularly constructed to read only int256 data from specified on-chain contracts' view functions. + +// Overview of the contract functionality: +// 1. Initialization: Through the constructor, it sets up the contract calls that the EZKL model will read from. +// 2. Data Quantization: Quantizes the returned data into a scaled fixed-point representation. See the `quantizeData` method for details. +// 3. Static Calls: Makes static calls to fetch data from other contracts. See the `staticCall` method. +// 4. Field Element Conversion: The fixed-point representation is then converted into a field element modulo P using the `toFieldElement` method. +// 5. Data Attestation: The `attestData` method validates that the public instances match the data fetched and processed by the contract. +// 6. Proof Verification: The `verifyWithDataAttestation` method parses the instances out of the encoded calldata and calls the `attestData` method to validate the public instances, +// then calls the `verifyProof` method to verify the proof on the verifier. + +contract DataAttestation { + /** + * @notice Struct used to make view only calls to accounts to fetch the data that EZKL reads from. + * @param the address of the account to make calls to + * @param the abi encoded function calls to make to the `contractAddress` + */ + struct AccountCall { + address contractAddress; + mapping(uint256 => bytes) callData; + mapping(uint256 => uint256) decimals; + uint256 callCount; + } + + AccountCall[1] public accountCalls; + + uint256[] public scales; + + address public admin; + + /** + * @notice EZKL P value + * @dev In order to prevent the verifier from accepting two version of the same pubInput, n and the quantity (n + P), where n + P <= 2^256, we require that all instances are stricly less than P. a + * @dev The reason for this is that the assmebly code of the verifier performs all arithmetic operations modulo P and as a consequence can't distinguish between n and n + P. + */ + uint256 constant ORDER = uint256(0x30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001); + + uint256 constant INPUT_CALLS = 4; + + uint256 constant OUTPUT_CALLS = 0; + + uint8 public instanceOffset; + + /** + * @dev Initialize the contract with account calls the EZKL model will read from. + * @param _contractAddresses - The calls to all the contracts EZKL reads storage from. + * @param _callData - The abi encoded function calls to make to the `contractAddress` that EZKL reads storage from. + */ + constructor( + address[] memory _contractAddresses, + bytes[][] memory _callData, + uint256[][] memory _decimals, + uint256[] memory _scales, + uint8 _instanceOffset, + address _admin + ) { + admin = _admin; + for (uint256 i; i < _scales.length; i++) { + scales.push(1 << _scales[i]); + } + populateAccountCalls(_contractAddresses, _callData, _decimals); + instanceOffset = _instanceOffset; + } + + function updateAdmin(address _admin) external { + require(msg.sender == admin, "Only admin can update admin"); + if (_admin == address(0)) { + revert(); + } + admin = _admin; + } + + function updateAccountCalls( + address[] memory _contractAddresses, + bytes[][] memory _callData, + uint256[][] memory _decimals + ) external { + require(msg.sender == admin, "Only admin can update instanceOffset"); + populateAccountCalls(_contractAddresses, _callData, _decimals); + } + + function populateAccountCalls( + address[] memory _contractAddresses, + bytes[][] memory _callData, + uint256[][] memory _decimals + ) internal { + require( + _contractAddresses.length == _callData.length && accountCalls.length == _contractAddresses.length, + "Invalid input length" + ); + require(_decimals.length == _contractAddresses.length, "Invalid number of decimals"); + // fill in the accountCalls storage array + uint256 counter = 0; + for (uint256 i = 0; i < _contractAddresses.length; i++) { + AccountCall storage accountCall = accountCalls[i]; + accountCall.contractAddress = _contractAddresses[i]; + accountCall.callCount = _callData[i].length; + for (uint256 j = 0; j < _callData[i].length; j++) { + accountCall.callData[j] = _callData[i][j]; + accountCall.decimals[j] = 10 ** _decimals[i][j]; + } + // count the total number of storage reads across all of the accounts + counter += _callData[i].length; + } + require(counter == INPUT_CALLS + OUTPUT_CALLS, "Invalid number of calls"); + } + + function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { + unchecked { + uint256 prod0; + uint256 prod1; + assembly { + let mm := mulmod(x, y, not(0)) + prod0 := mul(x, y) + prod1 := sub(sub(mm, prod0), lt(mm, prod0)) + } + + if (prod1 == 0) { + return prod0 / denominator; + } + + require(denominator > prod1, "Math: mulDiv overflow"); + + uint256 remainder; + assembly { + remainder := mulmod(x, y, denominator) + prod1 := sub(prod1, gt(remainder, prod0)) + prod0 := sub(prod0, remainder) + } + + uint256 twos = denominator & (~denominator + 1); + assembly { + denominator := div(denominator, twos) + prod0 := div(prod0, twos) + twos := add(div(sub(0, twos), twos), 1) + } + + prod0 |= prod1 * twos; + + uint256 inverse = (3 * denominator) ^ 2; + + inverse *= 2 - denominator * inverse; + inverse *= 2 - denominator * inverse; + inverse *= 2 - denominator * inverse; + inverse *= 2 - denominator * inverse; + inverse *= 2 - denominator * inverse; + inverse *= 2 - denominator * inverse; + + result = prod0 * inverse; + return result; + } + } + /** + * @dev Quantize the data returned from the account calls to the scale used by the EZKL model. + * @param data - The data returned from the account calls. + * @param decimals - The number of decimals the data returned from the account calls has (for floating point representation). + * @param scale - The scale used to convert the floating point value into a fixed point value. + */ + + function quantizeData(bytes memory data, uint256 decimals, uint256 scale) + internal + pure + returns (int256 quantized_data) + { + int256 x = abi.decode(data, (int256)); + bool neg = x < 0; + if (neg) { + x = -x; + } + uint256 output = mulDiv(uint256(x), scale, decimals); + if (mulmod(uint256(x), scale, decimals) * 2 >= decimals) { + output += 1; + } + // In the interest of keeping feature parity with the quantization done on the EZKL cli, + // we set the fixed point value type to be int128. Any value greater than that will throw an error + // as it does on the EZKL cli. + require(output <= uint128(type(int128).max), "Significant bit truncation"); + quantized_data = neg ? -int256(output) : int256(output); + } + /** + * @dev Make a static call to the account to fetch the data that EZKL reads from. + * @param target - The address of the account to make calls to. + * @param data - The abi encoded function calls to make to the `contractAddress` that EZKL reads storage from. + * @return The data returned from the account calls. (Must come from either a view or pure function. Will throw an error otherwise) + */ + + function staticCall(address target, bytes memory data) internal view returns (bytes memory) { + (bool success, bytes memory returndata) = target.staticcall(data); + if (success) { + if (returndata.length == 0) { + require(target.code.length > 0, "Address: call to non-contract"); + } + return returndata; + } else { + revert("Address: low-level call failed"); + } + } + /** + * @dev Convert the fixed point quantized data into a field element. + * @param x - The quantized data. + * @return field_element - The field element. + */ + + function toFieldElement(int256 x) internal pure returns (uint256 field_element) { + // The casting down to uint256 is safe because the order is about 2^254, and the value + // of x ranges of -2^127 to 2^127, so x + int(ORDER) is always positive. + return uint256(x + int256(ORDER)) % ORDER; + } + + /** + * @dev Make the account calls to fetch the data that EZKL reads from and attest to the data. + * @param instances - The public instances to the proof (the data in the proof that publicly accessible to the verifier). + */ + function attestData(uint256[] memory instances) internal view { + require(instances.length >= INPUT_CALLS + OUTPUT_CALLS, "Invalid public inputs length"); + uint256 _accountCount = accountCalls.length; + uint256 counter = 0; + for (uint8 i = 0; i < _accountCount; ++i) { + address account = accountCalls[i].contractAddress; + for (uint8 j = 0; j < accountCalls[i].callCount; j++) { + bytes memory returnData = staticCall(account, accountCalls[i].callData[j]); + uint256 scale = scales[counter]; + int256 quantized_data = quantizeData(returnData, accountCalls[i].decimals[j], scale); + uint256 field_element = toFieldElement(quantized_data); + require(field_element == instances[counter + instanceOffset], "Public input does not match"); + counter++; + } + } + } + + function verifyWithDataAttestation(address verifier, bytes memory encoded) public view returns (bool) { + require(verifier.code.length > 0, "Address: call to non-contract"); + bytes4 fnSelector; + uint256[] memory instances; + bytes memory paramData = new bytes(encoded.length - 4); + assembly { + /* + 4 (fun sig) + + 32 (verifier address) + + 32 (offset encoded) + + 32 (length encoded) = 100 bytes = 0x64 + */ + fnSelector := calldataload(0x64) + + mstore(add(paramData, 0x20), sub(mload(add(encoded, 0x20)), 4)) + for { let i := 0 } lt(i, sub(mload(encoded), 4)) { i := add(i, 0x20) } { + mstore(add(paramData, add(0x20, i)), mload(add(encoded, add(0x24, i)))) + } + } + if (fnSelector == 0xaf83a18d) { + // abi decode verifyProof(address,bytes,uint256[]) + (,, instances) = abi.decode(paramData, (address, bytes, uint256[])); + } else { + // abi decode verifyProof(bytes,uint256[]) + (, instances) = abi.decode(paramData, (bytes, uint256[])); + } + attestData(instances); + + // static call the verifier contract to verify the proof + (bool success, bytes memory returndata) = verifier.staticcall(encoded); + + if (success) { + return abi.decode(returndata, (bool)); + } else { + revert("low-level call to verifier failed"); + } + } +} diff --git a/test/lib/LibSign.sol b/test/lib/LibSign.sol new file mode 100644 index 0000000..465f7a1 --- /dev/null +++ b/test/lib/LibSign.sol @@ -0,0 +1,106 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {Coordinator} from "../../src/Coordinator.sol"; + +/// @title LibSign +/// @notice Useful helpers to create and verify EIP-712 signatures +/// @dev Purposefully does not inherit and use Solady helpers to force manual cross-verification +library LibSign { + /*////////////////////////////////////////////////////////////// + CONSTANTS + //////////////////////////////////////////////////////////////*/ + + /// @notice EIP-712 Coordinator.Subscription typeHash + bytes32 private constant SUBSCRIPTION_TYPEHASH = keccak256( + "Subscription(address owner,uint32 activeAt,uint32 period,uint32 frequency,uint16 redundancy,uint48 maxGasPrice,uint32 maxGasLimit,string containerId,bytes inputs)" + ); + + /// @notice EIP-712 DelegateSubscription typeHash + bytes32 private constant DELEGATE_SUBSCRIPTION_TYPEHASH = keccak256( + "DelegateSubscription(uint32 nonce,uint32 expiry,Subscription sub)Subscription(address owner,uint32 activeAt,uint32 period,uint32 frequency,uint16 redundancy,uint48 maxGasPrice,uint32 maxGasLimit,string containerId,bytes inputs)" + ); + + /*////////////////////////////////////////////////////////////// + UTILITY FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Generates EIP-712 domain seperator given name, version, and verifyingContract + /// @param name signing domain name + /// @param version major version of signing domain + /// @param verifyingContract address of contract verifying signature + /// @return domain seperator + function getDomainSeperator(string memory name, string memory version, address verifyingContract) + public + view + returns (bytes32) + { + return keccak256( + abi.encode( + // EIP712Domain + keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), + keccak256(bytes(name)), + keccak256(bytes(version)), + block.chainid, + verifyingContract + ) + ); + } + + /// @notice Generates structHash of a Coordinator.Subscription + /// @param sub subscription + /// @return structHash(subscription) + function getStructHash(Coordinator.Subscription memory sub) public pure returns (bytes32) { + return keccak256( + abi.encode( + SUBSCRIPTION_TYPEHASH, + sub.owner, + sub.activeAt, + sub.period, + sub.frequency, + sub.redundancy, + sub.maxGasPrice, + sub.maxGasLimit, + // Dynamic values must be encoded as hash of contents + keccak256(bytes(sub.containerId)), + keccak256(sub.inputs) + ) + ); + } + + /// @notice Generates structHash of a DelegateSubscription + /// @param nonce subscriber contract nonce + /// @param expiry signature expiry + /// @param sub subscription + /// @return structHash(struct(nonce, sub)) + function getStructHash(uint32 nonce, uint32 expiry, Coordinator.Subscription memory sub) + public + pure + returns (bytes32) + { + return keccak256(abi.encode(DELEGATE_SUBSCRIPTION_TYPEHASH, nonce, expiry, getStructHash(sub))); + } + + /// @notice Generates the hash of the fully encoded EIP-712 message, based on provided domain config + /// @param name signing domain name + /// @param version major version of signing domain + /// @param verifyingContract address of contract verifying signature + /// @param nonce subscriber contract nonce + /// @param expiry signature expiry + /// @param sub subscription + /// @return typed EIP-712 message hash + function getTypedMessageHash( + string memory name, + string memory version, + address verifyingContract, + uint32 nonce, + uint32 expiry, + Coordinator.Subscription memory sub + ) external view returns (bytes32) { + return keccak256( + abi.encodePacked( + "\x19\x01", getDomainSeperator(name, version, verifyingContract), getStructHash(nonce, expiry, sub) + ) + ); + } +} diff --git a/test/lib/LibStruct.sol b/test/lib/LibStruct.sol new file mode 100644 index 0000000..ca6d984 --- /dev/null +++ b/test/lib/LibStruct.sol @@ -0,0 +1,95 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {Coordinator} from "../../src/Coordinator.sol"; +import {MockBaseConsumer} from "../mocks/consumer/Base.sol"; + +/// @title LibStruct +/// @notice Useful helpers to (1) coerce native getters to structs, (2) re-export common structs +library LibStruct { + /*////////////////////////////////////////////////////////////// + STRUCTS + //////////////////////////////////////////////////////////////*/ + + /// @notice Reexported Coordinator.Subscription + /// @dev While still tightly-packed, ordering of variables is not identical to preserve test equality pre-change + struct Subscription { + uint32 activeAt; + address owner; + uint48 maxGasPrice; + uint16 redundancy; + uint32 maxGasLimit; + uint32 frequency; + uint32 period; + string containerId; + bytes inputs; + } + + /// @notice Reexported MockBaseConsumer.DeliveredOutput + struct DeliveredOutput { + uint32 subscriptionId; + uint32 interval; + uint16 redundancy; + address node; + bytes input; + bytes output; + bytes proof; + } + + /*////////////////////////////////////////////////////////////// + UTILITY FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Coerce Coordinator.subscriptions to LibStruct.Subscription + /// @param coordinator coordinator + /// @param subscriptionId subscriptionId + /// @return LibStruct.Subscription + function getSubscription(Coordinator coordinator, uint32 subscriptionId) + external + view + returns (LibStruct.Subscription memory) + { + // Collect subscription from storage + ( + address owner, + uint32 activeAt, + uint32 period, + uint32 frequency, + uint16 redundancy, + uint48 maxGasPrice, + uint32 maxGasLimit, + string memory containerId, + bytes memory inputs + ) = coordinator.subscriptions(subscriptionId); + + // Return created struct + return LibStruct.Subscription( + activeAt, owner, maxGasPrice, redundancy, maxGasLimit, frequency, period, containerId, inputs + ); + } + + /// @notice Coerce MockBaseConsumer.outputs to LibStruct.DeliveredOutput + /// @param consumer consumer + /// @param subId subscription ID + /// @param interval subscription interval + /// @param redundancy # node response + function getDeliveredOutput(MockBaseConsumer consumer, uint32 subId, uint32 interval, uint16 redundancy) + external + view + returns (LibStruct.DeliveredOutput memory) + { + // Collect delivered output from storage + ( + uint32 id, + uint32 subInterval, + uint16 subRedundancy, + address node, + bytes memory input, + bytes memory output, + bytes memory proof + ) = consumer.outputs(subId, interval, redundancy); + + // Return created struct + return LibStruct.DeliveredOutput(id, subInterval, subRedundancy, node, input, output, proof); + } +} diff --git a/test/mocks/MockManager.sol b/test/mocks/MockManager.sol new file mode 100644 index 0000000..8047b45 --- /dev/null +++ b/test/mocks/MockManager.sol @@ -0,0 +1,19 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {Manager} from "../../src/Manager.sol"; + +/// @title MockManager +/// @notice Mocks Manager contract +/// @dev Useful to test manager functions independent to coordinator +contract MockManager is Manager { + /*////////////////////////////////////////////////////////////// + UTILITY FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Returns true if caller has status `NodeStatus.Active` or reverts + /// @dev Essentially testing that exposed `onlyActiveNode` modifier works + function isActiveNode() external view onlyActiveNode returns (bool) { + return true; + } +} diff --git a/test/mocks/MockNode.sol b/test/mocks/MockNode.sol new file mode 100644 index 0000000..bd5a8e5 --- /dev/null +++ b/test/mocks/MockNode.sol @@ -0,0 +1,123 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {Manager} from "../../src/Manager.sol"; +import {MockManager} from "./MockManager.sol"; +import {StdAssertions} from "forge-std/StdAssertions.sol"; +import {EIP712Coordinator} from "../../src/EIP712Coordinator.sol"; + +/// @title MockNode +/// @notice Mocks the functionality of an off-chain Infernet node +/// @dev Inherited functions contain state checks but not event or error checks and do not interrupt parent reverts (with reverting pre-checks) +contract MockNode is StdAssertions { + /*////////////////////////////////////////////////////////////// + INTERNAL + //////////////////////////////////////////////////////////////*/ + + /// @notice Coordinator + EIP712Coordinator internal COORDINATOR; + + /*////////////////////////////////////////////////////////////// + CONSTRUCTOR + //////////////////////////////////////////////////////////////*/ + + /// Creates new MockNode + /// @param _coordinator Coordinator + constructor(EIP712Coordinator _coordinator) { + COORDINATOR = _coordinator; + } + + /*////////////////////////////////////////////////////////////// + UTILITY FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Returns node cooldown start timestamp + function cooldownStart() public view returns (uint32) { + (, uint32 startTimestamp) = COORDINATOR.nodeInfo(address(this)); + return startTimestamp; + } + + /// @notice Asserts node status against status to check + /// @param status status to check + function assertNodeStatus(Manager.NodeStatus status) public { + (Manager.NodeStatus actual,) = COORDINATOR.nodeInfo(address(this)); + assertEq(uint8(actual), uint8(status)); + } + + /// @notice Checks if node has `NodeStatus.Active` or reverts + /// @dev MockManager-only function, thus forced interface + function isActiveNode() public view returns (bool) { + return MockManager(address(COORDINATOR)).isActiveNode(); + } + + /*////////////////////////////////////////////////////////////// + INHERITED FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @dev Augmented with checks + /// @dev Checks status change to `NodeStatus.Registered` + /// @dev Checks that cooldown start timestamp for node has been updated to current timestamp + function registerNode(address node) external { + // Initialize registration + uint256 currentTimestamp = block.timestamp; + COORDINATOR.registerNode(node); + + // Check status + (Manager.NodeStatus status, uint32 cds) = COORDINATOR.nodeInfo(address(this)); + assertEq(uint8(status), uint8(Manager.NodeStatus.Registered)); + + // Ensure cooldown start timestamp conforms to current timestamp + assertEq(currentTimestamp, cds); + } + + /// @dev Augmented with checks + /// @dev Checks status change to `NodeStatus.Active` + /// @dev Checks node cooldown start timestamp is zeroed out + function activateNode() external { + COORDINATOR.activateNode(); + + // Check status + assertNodeStatus(Manager.NodeStatus.Active); + // Ensure cooldown start timestamp is nullified + assertEq(cooldownStart(), 0); + } + + /// @dev Augmented with checks + /// @dev Checks status change to `NodeStatus.Inactive` + /// @dev Checks node cooldown start timestamp is zeroed out + function deactivateNode() external { + COORDINATOR.deactivateNode(); + + // Check status + assertNodeStatus(Manager.NodeStatus.Inactive); + // Ensure cooldown start timestamp is nullified + assertEq(cooldownStart(), 0); + } + + /// @dev Wrapper function (calling Coordinator with msg.sender == node) + function deliverCompute( + uint32 subscriptionId, + uint32 deliveryInterval, + bytes calldata input, + bytes calldata output, + bytes calldata proof + ) external { + COORDINATOR.deliverCompute(subscriptionId, deliveryInterval, input, output, proof); + } + + /// @dev Wrapper function (calling Coordinator with msg.sender == node) + function deliverComputeDelegatee( + uint32 nonce, + uint32 expiry, + EIP712Coordinator.Subscription calldata sub, + uint8 v, + bytes32 r, + bytes32 s, + uint32 deliveryInterval, + bytes calldata input, + bytes calldata output, + bytes calldata proof + ) external { + COORDINATOR.deliverComputeDelegatee(nonce, expiry, sub, v, r, s, deliveryInterval, input, output, proof); + } +} diff --git a/test/mocks/consumer/Base.sol b/test/mocks/consumer/Base.sol new file mode 100644 index 0000000..f5b553c --- /dev/null +++ b/test/mocks/consumer/Base.sol @@ -0,0 +1,35 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +/// @title MockBaseConsumer +/// @notice Mocks BaseConsumer contract +abstract contract MockBaseConsumer { + /*////////////////////////////////////////////////////////////// + STRUCTS + //////////////////////////////////////////////////////////////*/ + + /// @notice Output delivered from node + /// @param subscriptionId subscription ID + /// @param interval subscription interval + /// @param redundancy after this call succeeds, how many nodes will have delivered a response for this interval + /// @param node responding node address + /// @param input optional off-chain container input recorded by Infernet node (empty, hashed input, processed input, or both) + /// @param output optional off-chain container output (empty, hashed output, processed output, both, or fallback: all encodeable data) + /// @param proof optional off-chain container execution proof (or arbitrary metadata) + struct DeliveredOutput { + uint32 subscriptionId; + uint32 interval; + uint16 redundancy; + address node; + bytes input; + bytes output; + bytes proof; + } + + /*////////////////////////////////////////////////////////////// + MUTABLE + //////////////////////////////////////////////////////////////*/ + + /// @notice Subscription ID => Interval => Redundancy => DeliveredOutput + mapping(uint32 => mapping(uint32 => mapping(uint16 => DeliveredOutput))) public outputs; +} diff --git a/test/mocks/consumer/Callback.sol b/test/mocks/consumer/Callback.sol new file mode 100644 index 0000000..c879913 --- /dev/null +++ b/test/mocks/consumer/Callback.sol @@ -0,0 +1,90 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {MockBaseConsumer} from "./Base.sol"; +import {LibStruct} from "../../lib/LibStruct.sol"; +import {StdAssertions} from "forge-std/StdAssertions.sol"; +import {CallbackConsumer} from "../../../src/consumer/Callback.sol"; + +/// @title MockCallbackConsumer +/// @notice Mocks CallbackConsumer +contract MockCallbackConsumer is MockBaseConsumer, CallbackConsumer, StdAssertions { + /*////////////////////////////////////////////////////////////// + CONSTRUCTOR + //////////////////////////////////////////////////////////////*/ + + /// Create new MockCallbackConsumer + /// @param _coordinator coordinator address + constructor(address _coordinator) CallbackConsumer(_coordinator) {} + + /*////////////////////////////////////////////////////////////// + UTILITY FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Create new mock callback request + /// @dev Parameter interface conforms to same as `CallbackConsumer._requestCompute` + /// @dev Augmented with checks + /// @dev Checks returned subscription ID is serially conforming + /// @dev Checks subscription stored in coordinator storage conforms to expected, given inputs + function createMockRequest( + string calldata containerId, + bytes calldata inputs, + uint48 maxGasPrice, + uint32 maxGasLimit, + uint16 redundancy + ) external returns (uint32) { + // Get current block timestamp + uint256 currentTimestamp = block.timestamp; + // Get expected subscription ID + uint32 expectedSubscriptionID = COORDINATOR.id(); + + // Request off-chain container compute + uint32 actualSubscriptionID = _requestCompute(containerId, inputs, maxGasPrice, maxGasLimit, redundancy); + + // Assert ID expectations + assertEq(expectedSubscriptionID, actualSubscriptionID); + + // Collect subscription from storage + LibStruct.Subscription memory sub = LibStruct.getSubscription(COORDINATOR, actualSubscriptionID); + + // Assert subscription storage + assertEq(sub.activeAt, currentTimestamp); + assertEq(sub.owner, address(this)); + assertEq(sub.maxGasPrice, maxGasPrice); + assertEq(sub.redundancy, redundancy); + assertEq(sub.maxGasLimit, maxGasLimit); + assertEq(sub.frequency, 1); + assertEq(sub.period, 0); + assertEq(sub.containerId, containerId); + assertEq(sub.inputs, inputs); + + // Explicitly return subscription ID + return actualSubscriptionID; + } + + /*////////////////////////////////////////////////////////////// + INHERITED FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Overrides internal function, pushing received response to delivered outputs map + function _receiveCompute( + uint32 subscriptionId, + uint32 interval, + uint16 redundancy, + address node, + bytes calldata input, + bytes calldata output, + bytes calldata proof + ) internal override { + // Log delivered output + outputs[subscriptionId][interval][redundancy] = DeliveredOutput({ + subscriptionId: subscriptionId, + interval: interval, + redundancy: redundancy, + node: node, + input: input, + output: output, + proof: proof + }); + } +} diff --git a/test/mocks/consumer/DelegatorCallback.sol b/test/mocks/consumer/DelegatorCallback.sol new file mode 100644 index 0000000..827175a --- /dev/null +++ b/test/mocks/consumer/DelegatorCallback.sol @@ -0,0 +1,31 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {MockCallbackConsumer} from "./Callback.sol"; +import {Delegator} from "../../../src/pattern/Delegator.sol"; + +/// @title MockDelegatorCallbackConsumer +/// @notice Mocks CallbackConsumer w/ delegator set to an address +contract MockDelegatorCallbackConsumer is Delegator, MockCallbackConsumer { + /*////////////////////////////////////////////////////////////// + CONSTRUCTOR + //////////////////////////////////////////////////////////////*/ + + /// Create new MockDelegatorCallbackConsumer + /// @param _coordinator coordinator address + /// @param _signer delegated signer address + constructor(address _coordinator, address _signer) MockCallbackConsumer(_coordinator) Delegator(_signer) {} + + /*////////////////////////////////////////////////////////////// + INHERITED FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Update new signer + /// @param newSigner to update + /// @dev Checks signer is updated after calling + function updateMockSigner(address newSigner) external { + _updateSigner(newSigner); + + assertEq(signer, newSigner); + } +} diff --git a/test/mocks/consumer/Subscription.sol b/test/mocks/consumer/Subscription.sol new file mode 100644 index 0000000..779d887 --- /dev/null +++ b/test/mocks/consumer/Subscription.sol @@ -0,0 +1,123 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +pragma solidity ^0.8.4; + +import {MockBaseConsumer} from "./Base.sol"; +import {LibStruct} from "../../lib/LibStruct.sol"; +import {StdAssertions} from "forge-std/StdAssertions.sol"; +import {SubscriptionConsumer} from "../../../src/consumer/Subscription.sol"; + +/// @title MockSubscriptionConsumer +/// @notice Mocks SubscriptionConsumer +contract MockSubscriptionConsumer is MockBaseConsumer, SubscriptionConsumer, StdAssertions { + /*////////////////////////////////////////////////////////////// + CONSTANTS + //////////////////////////////////////////////////////////////*/ + + /// @notice Hard-coded container inputs + bytes public constant CONTAINER_INPUTS = bytes("CONTAINER_INPUTS"); + + /*////////////////////////////////////////////////////////////// + CONSTRUCTOR + //////////////////////////////////////////////////////////////*/ + + /// Create new MockSubscriptionConsumer + /// @param _coordinator coordinator address + constructor(address _coordinator) SubscriptionConsumer(_coordinator) {} + + /*////////////////////////////////////////////////////////////// + UTILITY FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Create new mock subscription + /// @dev Parameter interface conforms to same as `SubscriptionConsumer._createContainerSubscription` + /// @dev Augmented with checks + /// @dev Checks returned subscription ID is serially conforming + /// @dev Checks subscription stored in coordinator storage conforms to expected, given inputs + function createMockSubscription( + string calldata containerId, + uint48 maxGasPrice, + uint32 maxGasLimit, + uint32 frequency, + uint32 period, + uint16 redundancy + ) external returns (uint32) { + // Get current block timestamp + uint256 currentTimestamp = block.timestamp; + // Get expected subscription id + uint32 exepectedSubscriptionID = COORDINATOR.id(); + + // Create new subscription + uint32 actualSubscriptionID = + _createComputeSubscription(containerId, maxGasPrice, maxGasLimit, frequency, period, redundancy); + + // Assert ID expectations + assertEq(exepectedSubscriptionID, actualSubscriptionID); + + // Collect subscription from storage + LibStruct.Subscription memory sub = LibStruct.getSubscription(COORDINATOR, actualSubscriptionID); + + // Assert subscription storage + assertEq(sub.activeAt, currentTimestamp + period); + assertEq(sub.owner, address(this)); + assertEq(sub.maxGasPrice, maxGasPrice); + assertEq(sub.redundancy, redundancy); + assertEq(sub.maxGasLimit, maxGasLimit); + assertEq(sub.frequency, frequency); + assertEq(sub.period, period); + assertEq(sub.containerId, containerId); + assertEq(sub.inputs, ""); + + // Explicitly return subscription ID + return actualSubscriptionID; + } + + /// @notice Allows cancelling subscription + /// @param subscriptionId to cancel + /// @dev Augmented with checks + /// @dev Asserts subscription owner is nullified after cancellation + function cancelMockSubscription(uint32 subscriptionId) external { + _cancelComputeSubscription(subscriptionId); + + // Get subscription owner & assert zeroed-out + address expected = address(0); + (address actual,,,,,,,,) = COORDINATOR.subscriptions(subscriptionId); + assertEq(actual, expected); + } + + /*////////////////////////////////////////////////////////////// + INHERITED FUNCTIONS + //////////////////////////////////////////////////////////////*/ + + /// @notice Override function to return container inputs + /// @return container inputs + function getContainerInputs(uint32 subscriptionId, uint32 interval, uint32 timestamp, address caller) + external + pure + override + returns (bytes memory) + { + return CONTAINER_INPUTS; + } + + /// @notice Overrides internal function, pushing received response to delivered outputs map + function _receiveCompute( + uint32 subscriptionId, + uint32 interval, + uint16 redundancy, + address node, + bytes calldata input, + bytes calldata output, + bytes calldata proof + ) internal override { + // Log delivered output + outputs[subscriptionId][interval][redundancy] = DeliveredOutput({ + subscriptionId: subscriptionId, + interval: interval, + redundancy: redundancy, + node: node, + input: input, + output: output, + proof: proof + }); + } +}